& plane,
+ int32& cullingPlaneIndex = dummy,
+ const uint32 testMask = -1) const;
bool contains(
const Vector3& point) const;
- /** @deprecated */
- float surfaceArea() const;
-
- inline float area() const {
- return surfaceArea();
- }
+ float area() const;
float volume() const;
- void getRandomSurfacePoint(Vector3& P, Vector3& N = Vector3::dummy) const;
-
- /**
- @deprecated
- Uniformly distributed on the surface.
- */
- inline Vector3 randomSurfacePoint() const {
- Vector3 V;
- getRandomSurfacePoint(V);
- return V;
- }
+ void getRandomSurfacePoint(Vector3& P, Vector3& N = Vector3::ignore()) const;
/**
Uniformly distributed on the interior (includes surface)
@@ -221,6 +184,10 @@ public:
Vector3 randomInteriorPoint() const;
void getBounds(class AABox&) const;
+
+ bool isFinite() const {
+ return G3D::isFinite(_volume);
+ }
};
}
diff --git a/dep/include/g3dlite/G3D/Box2D.h b/dep/include/g3dlite/G3D/Box2D.h
new file mode 100644
index 000000000..80accad89
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Box2D.h
@@ -0,0 +1,121 @@
+/**
+ @file Box2D.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2001-06-02
+ @edited 2008-12-27
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_Box2D_h
+#define G3D_Box2D_h
+
+#include "G3D/platform.h"
+#include "G3D/Vector2.h"
+
+namespace G3D {
+
+class CoordinateFrame;
+typedef class CoordinateFrame CFrame;
+class Rect2D;
+typedef class Rect2D AABox2D;
+
+/**
+ 2D oriented box
+ @cite http://www.flipcode.com/archives/2D_OBB_Intersection.shtml
+ */
+class Box2D {
+private:
+ /** Corners of the box, where 0 is the lower left. */
+ Vector2 m_corner[4];
+
+ /** Two edges of the box extended away from corner[0], with length
+ = 1 / extentSquared */
+ Vector2 m_axisin[2];
+
+ /** Two edges of the box extended away from corner[0], with unit length */
+ Vector2 m_axis[2];
+
+ /** Centroid of the box */
+ Vector2 m_center;
+
+ /** origin[a] = m_corner[0].dot(m_axisin[a]); */
+ float origin[2];
+
+ /** Surface area */
+ float m_area;
+
+ Vector2 m_extent;
+
+ /** Returns true if other overlaps one dimension of this. */
+ bool overlaps1Way(const Box2D& other) const;
+
+
+ /** Updates the axes after the m_corners move. Assumes the
+ m_corners actually form a rectangle. */
+ void computeAxes();
+
+public:
+
+ /**
+ @param center World-space center
+ @param w Width along object-space x-axis
+ @param h Height along object-space y-axis
+ @param angle Counter-clockwise angle from object-space x-axis in radians
+ */
+ Box2D(const Vector2& center = Vector2(0, 0), float w = 0, float h = 0, float angle = 0);
+
+ Box2D(const AABox2D& b);
+
+ Box2D(const Vector2& min, const Vector2& max);
+
+ /** Transform @a b by @a frame, discarding the Z components, and
+ compute the new box.*/
+ Box2D(const CFrame& frame, Box2D& b);
+
+ inline bool contains(const Vector2& v) const {
+ // Take to object space:
+ const Vector2& p = v - m_center;
+ float x = p.dot(m_axisin[0]);
+ float y = p.dot(m_axisin[1]);
+
+ // Must be within extent/2 on both axes in object space
+ return (abs(x) <= 0.5f) && (abs(y) <= 0.5f);
+ }
+
+ /** @brief Distance from corner(0) to the next corner along the box's local axis a. */
+ inline const Vector2& extent() const {
+ return m_extent;
+ }
+
+ /** @brief Unit length vector along axis @a a */
+ inline const Vector2& axis(int a) const {
+ debugAssert(a == 0 || a == 1);
+ return m_axis[a];
+ }
+
+ /** @brief Surface area */
+ inline float area() const {
+ return m_area;
+ }
+
+ inline const Vector2& corner(int i) const {
+ debugAssert(i >=0 && i <= 3);
+ return m_corner[i];
+ }
+
+ inline const Vector2& center() const {
+ return m_center;
+ }
+
+ /** Returns true if the intersection of the boxes is non-empty. */
+ inline bool overlaps(const Box2D& other) const {
+ return overlaps1Way(other) && other.overlaps1Way(*this);
+ }
+};
+
+} // G3D
+#endif
diff --git a/dep/include/g3dlite/G3D/BumpMapPreprocess.h b/dep/include/g3dlite/G3D/BumpMapPreprocess.h
new file mode 100644
index 000000000..955f99e61
--- /dev/null
+++ b/dep/include/g3dlite/G3D/BumpMapPreprocess.h
@@ -0,0 +1,61 @@
+/**
+ \file BumpMapPreprocess.h
+
+ \maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ \created 2010-01-28
+ \edited 2010-01-28
+
+ Copyright 2000-2010, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_BumpMapPreprocess_h
+#define G3D_BumpMapPreprocess_h
+
+#include "G3D/platform.h"
+
+namespace G3D {
+class Any;
+
+/**
+Not in the BumpMap class to avoid a circular dependency between Texture and BumpMap.
+G3D::GImage::computeNormalMap().
+*/
+class BumpMapPreprocess {
+public:
+
+ /** If true, the elevations are box filtered after computing normals
+ and before uploading, which produces better results for parallax offset mapping
+ Defaults to false. */
+ bool lowPassFilter;
+
+ /** Height of the maximum ("white") value, in pixels, for the purpose of computing normals.
+ A value of 255 means that a 255 x 255 bump image with a full black-to-white gradient
+ will produce a 45-degree ramp (this also results in "cubic" voxels).
+ A negative value means to set zExtentPixels to -zExtentPixels * max(width, height).
+ The default is -0.02.
+ */
+ float zExtentPixels;
+
+ /** After computing normals, scale the height by |N.z|, a trick that reduces texture swim in steep areas for parallax offset
+ mapping. Defaults to false.*/
+ bool scaleZByNz;
+
+ BumpMapPreprocess() : lowPassFilter(false), zExtentPixels(-0.02f), scaleZByNz(false) {}
+
+ BumpMapPreprocess(const Any& any);
+
+ operator Any() const;
+
+ bool operator==(const BumpMapPreprocess& other) const {
+ return
+ (lowPassFilter == other.lowPassFilter) &&
+ (zExtentPixels == other.zExtentPixels) &&
+ (scaleZByNz == other.scaleZByNz);
+ }
+};
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Capsule.h b/dep/include/g3dlite/G3D/Capsule.h
new file mode 100644
index 000000000..baeea3aa8
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Capsule.h
@@ -0,0 +1,90 @@
+/**
+ @file Capsule.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-02-07
+ @edited 2005-08-20
+
+ Copyright 2000-2006, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_CAPSULE_H
+#define G3D_CAPSULE_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/Vector3.h"
+
+namespace G3D {
+
+class Line;
+class AABox;
+/**
+ A shape formed by extruding a sphere along a line segment.
+ */
+class Capsule {
+private:
+ Vector3 p1;
+ Vector3 p2;
+
+ float _radius;
+public:
+
+
+ /** Uninitialized */
+ Capsule();
+ Capsule(class BinaryInput& b);
+ Capsule(const Vector3& _p1, const Vector3& _p2, float _r);
+ void serialize(class BinaryOutput& b) const;
+ void deserialize(class BinaryInput& b);
+
+ /** The line down the center of the capsule */
+ Line axis() const;
+
+ inline float radius() const {
+ return _radius;
+ }
+
+ /** Argument may be 0 or 1 */
+ inline Vector3 point(int i) const {
+ debugAssert(i == 0 || i == 1);
+ return (i == 0) ? p1 : p2;
+ }
+
+ /** Distance between the sphere centers. The total extent of the cylinder is
+ 2r + h. */
+ inline float height() const {
+ return (p1 - p2).magnitude();
+ }
+
+ inline Vector3 center() const {
+ return (p1 + p2) / 2.0;
+ }
+
+ /** Get a reference frame in which the center of mass is the origin and Y is the axis of the capsule.*/
+ void getReferenceFrame(class CoordinateFrame& cframe) const;
+
+ /**
+ Returns true if the point is inside the capsule or on its surface.
+ */
+ bool contains(const Vector3& p) const;
+
+ float volume() const;
+
+ float area() const;
+
+ /** Get axis aligned bounding box */
+ void getBounds(AABox& out) const;
+
+ /** Random world space point with outward facing normal. */
+ void getRandomSurfacePoint(Vector3& P, Vector3& N) const;
+
+ /** Point selected uniformly at random over the volume. */
+ Vector3 randomInteriorPoint() const;
+};
+
+} // namespace
+
+#endif
diff --git a/dep/include/g3dlite/G3D/CollisionDetection.h b/dep/include/g3dlite/G3D/CollisionDetection.h
index 4dc8b2653..c8fcf5534 100644
--- a/dep/include/g3dlite/G3D/CollisionDetection.h
+++ b/dep/include/g3dlite/G3D/CollisionDetection.h
@@ -4,17 +4,18 @@
Moving collision detection for simple primitives.
- @author Morgan McGuire, matrix@graphics3d.com
+ @author Morgan McGuire, http://graphics.cs.williams.edu
@cite Spherical collision based on Paul Nettle's
ftp://ftp.3dmaileffects.com/pub/FluidStudios/CollisionDetection/Fluid_Studios_Generic_Collision_Detection_for_Games_Using_Ellipsoids.pdf
and comments by Max McGuire. Ray-sphere intersection by Eric Haines.
Box-Box intersection written by Kevin Egan.
Thanks to Max McGuire of Iron Lore for various bug fixes.
+ Box-Triangle by Tomas Akenine-Moller
@created 2001-11-19
- @edited 2006-01-10
+ @edited 2008-12-19
- Copyright 2000-2006, Morgan McGuire.
+ Copyright 2000-2009, Morgan McGuire.
All rights reserved.
*/
@@ -68,17 +69,17 @@ namespace G3D {
| Vector3 | LineSegment | Ray * | Line | Plane | Triangle | Sphere | Cylinder | Capsule | AABox | Box |
- | Vector3 | Vector3::operator== Vector3::fuzzyEq G3D::distance | |
- | LineSegment | LineSegment::closestPoint LineSegment::distance CollisionDetection::closestPointOnLineSegment | | |
+ | Vector3 | \link Vector3::operator== V3::==\endlink \link Vector3::fuzzyEq V3::fuzzy \endlink \link G3D::distance distance \endlink | |
+ | LineSegment | \link LineSegment::closestPoint LS::closestPoint\endlink \link LineSegment::distance LS::distance\endlink \link CollisionDetection::closestPointOnLineSegment CD\endlink | | |
| Ray * | Ray::closestPoint Ray::distance | | | |
- | Line | Line::closestPoint Line::distance | | CollisionDetection::closestPointsBetweenLineAndLine | | |
+ | Line | Line::closestPoint Line::distance | | \link CollisionDetection::closestPointsBetweenLineAndLine CD\endlink | | |
| Plane | | | | | | |
| Triangle | | | | | | | |
- | Sphere | Sphere::contains | | | | | | | |
+ | Sphere | Sphere::contains | | \link CollisionDetection::collisionTimeForMovingPointFixedSphere CD \endlink, \link Ray::intersectionTime R::time\endlink | | | | | |
| Cylinder | Cylinder::contains | | | | | | | | |
| Capsule | Capsule::contains | | | | | | | | | |
- | AABox | AABox::contains | | | | | | | | | | |
- | Box | Box::contains | (treat as Ray) | CollisionDetection::collisionTimeForMovingPointFixedBox | (treat as Ray) | CollisionDetection::penetrationDepthForFixedBoxFixedPlane | CollisionDetection::penetrationDepthForFixedBoxFixedPlane | CollisionDetection::penetrationDepthForFixedSphereFixedBox | None (use OPCODE) | CollisionDetection::movingSpherePassesThroughFixedBox | CollisionDetection::penetrationDepthForFixedBoxFixedBox | CollisionDetection::penetrationDepthForFixedBoxFixedBox |
+ | AABox | AABox::contains | | | | | \link CollisionDetection::fixedSolidBoxIntersectsFixedTriangle CD\endlink | | | | | |
+ | Box | Box::contains | (treat as Ray) | \link CollisionDetection::collisionTimeForMovingPointFixedBox CD\endlink | (treat as Ray) | \link CollisionDetection::penetrationDepthForFixedBoxFixedPlane CD \endlink | \link CollisionDetection::penetrationDepthForFixedBoxFixedPlane CD\endlink | \link CollisionDetection::penetrationDepthForFixedSphereFixedBox CD\endlink | None (use OPCODE) | \link CollisionDetection::movingSpherePassesThroughFixedBox CD \endlink | \link CollisionDetection::penetrationDepthForFixedBoxFixedBox CD\endlink | \link CollisionDetection::penetrationDepthForFixedBoxFixedBox CD\endlink |
@@ -86,6 +87,8 @@ namespace G3D {
* Note: Moving collision detection against certain primitives is equivalent to static collision
detection against a bigger primitive. Ray, Line Segment == ``moving Point''; Capsule ==``moving Sphere''; Plane == ``moving Line''
+
+ @deprecated Routines moving to the G3D::Intersect class in G3D 8.0
*/
class CollisionDetection {
private:
@@ -404,11 +407,11 @@ public:
Plane as well as the deepest point of the sphere that penetrates the plane
and the plane normal at that intersection.
- @param sphere Fixed Sphere.
- @param plane Fixed Plane.
- @param contactPoints Sphere point that penetrates the plane.
+ @param sphereA Fixed Sphere.
+ @param planeB Fixed Plane.
+ @param contactPoints Sphere point that penetrates the plane.
[Post Condition]
- @param contactNormals Normal at penetration point. [Post Condition]
+ @param contactNormals Normal at penetration point. [Post Condition]
@return Depth of penetration. If there is no intersection between the
objects then the depth will be a negative value.
@@ -477,8 +480,6 @@ public:
@param v0 Triangle vertex 1.
@param v1 Triangle vertex 2.
@param v2 Triangle vertex 3
- @param location Location of collision. [Post Condition]
- (Infinite vector on no collision)
@return Time til collision. If there is no collision then the return
value will be inf().
@@ -519,7 +520,7 @@ public:
const Vector3& v2,
Vector3& location) {
float t = collisionTimeForMovingPointFixedTriangle(orig, dir, v0, v1, v2);
- if (t < inf()) {
+ if (t < finf()) {
location = orig + dir * t;
}
return t;
@@ -553,7 +554,7 @@ public:
float t = collisionTimeForMovingPointFixedTriangle(
orig, dir, tri.vertex(0), tri.vertex(1), tri.vertex(2));
- if ((t < inf()) && (&location != &ignore)) {
+ if ((t < finf()) && (&location != &ignore)) {
location = orig + dir * t;
normal = tri.normal();
}
@@ -589,21 +590,20 @@ public:
Vector3& location,
Vector3& normal) {
float t = collisionTimeForMovingPointFixedTriangle(orig, dir, v0, v1, v2);
- if (t < inf()) {
+ if (t < finf()) {
location = orig + dir * t;
- normal = (v2 - v0).cross(v1 - v0).direction();
+ normal = (v1 - v0).cross(v2 - v0).direction();
}
return t;
}
/**
- Unlike other methods, does not support an output normal.
If the ray origin is inside the box, returns inf() but inside
is set to true.
Beta API
@cite Andrew Woo, from "Graphics Gems", Academic Press, 1990
- @cite Optimized code by Pierre Terdiman, 2000 (~20-30% faster on my Celeron 500)
+ @cite Optimized code by Pierre Terdiman, 2000 (~20-30% faster on Celeron 500)
@cite Epsilon value added by Klaus Hartmann
@cite http://www.codercorner.com/RayAABB.cpp
*/
@@ -639,6 +639,29 @@ public:
bool& inside = ignoreBool,
Vector3& normal = ignore);
+
+ /**
+ @brief Calculates intersection of a ray and a static
+ Axis-Aligned Box (AABox).
+
+ @note Avoids the sqrt from collisionTimeForMovingPointFixedAABox;
+ early-out branches and operations optimized for Intel Core2 architecture.
+
+ @param invDir 1/dir
+ @param location Location of collision. [Post Condition]
+ @param inside Does the ray originate inside the box? [Post Condition]
+
+ @return True if the ray hits the box
+ */
+ static bool __fastcall rayAABox(
+ const Ray& ray,
+ const Vector3& invDir,
+ const AABox& box,
+ const Vector3& boxCenter,
+ float boundingRadiusSquared,
+ Vector3& location,
+ bool& inside);
+
/**
Calculates time between the intersection of a moving point and a fixed
sphere.
@@ -648,11 +671,12 @@ public:
@param point Moving point.
@param velocity Point's velocity.
- @param Sphere Fixed Sphere.
- @param location Location of collision. [Post Condition]
+ @param sphere Fixed Sphere.
+ @param outLocation Location of collision. [Post Condition]
@param outNormal Sphere's surface normal to collision [Post Condition]
+ \param solid If true, rays inside the sphere immediately intersect (good for collision detection). If false, they hit the opposite side of the sphere (good for ray tracing).
- @return Time til collision. If there is no collision then the return
+ @return Time until collision. If there is no collision then the return
value will be inf().
*/
static float collisionTimeForMovingPointFixedSphere(
@@ -660,7 +684,8 @@ public:
const Vector3& velocity,
const class Sphere& sphere,
Vector3& outLocation,
- Vector3& outNormal = ignore);
+ Vector3& outNormal = ignore,
+ bool solid = false);
/**
Calculates time between the intersection of a moving point and a fixed
@@ -721,7 +746,7 @@ public:
@param point Moving point.
@param velocity Point's velocity.
@param capsule Fixed capsule.
- @param location Location of collision. [Post Condition]
+ @param outLocation Location of collision. [Post Condition]
@param outNormal Capsule's surface normal to collision [Post Condition]
@return Time til collision. If there is no collision then the return
@@ -741,7 +766,7 @@ public:
@param sphere Moving sphere.
@param velocity Sphere's velocity.
@param plane Fixed Plane.
- @param location Location of collision -- not center position of sphere
+ @param outLocation Location of collision -- not center position of sphere
at the collision time. [Post Condition]
@param outNormal Box's surface normal to collision [Post Condition]
@@ -761,10 +786,11 @@ public:
@param sphere Moving sphere.
@param velocity Sphere's velocity.
- @param triangle Fixed Triangle.
- @param location Location of collision -- not center position of sphere
- at the collision time. [Post Condition]
- @param outNormal Box's surface normal to collision [Post Condition]
+ @param triangle Fixed Triangle. (collisions can happen on the back side of the triangle)
+ @param outLocation Location of collision, if collision occurs -- not center position of sphere
+ at the collision time. If there is interpenetration at the start, this point may be inside
+ the sphere.
+ @param b Barycentric coordinates. These are not valid unless collision occurs.
@return Time til collision. If there is no collision then the return
value will be inf().
@@ -772,9 +798,9 @@ public:
static float collisionTimeForMovingSphereFixedTriangle(
const class Sphere& sphere,
const Vector3& velocity,
- const Triangle& triangle,
+ const Triangle& triangle,
Vector3& outLocation,
- Vector3& outNormal = ignore);
+ float b[3] = (float*)&ignore);
/**
Calculates time between the intersection of a moving sphere and a fixed
@@ -786,7 +812,7 @@ public:
@param v1 Rectangle vertex 2.
@param v2 Rectangle vertex 3
@param v3 Rectangle vertex 4.
- @param location Location of collision -- not center position of sphere
+ @param outLocation Location of collision -- not center position of sphere
at the collision time. [Post Condition]
@param outNormal Box's surface normal to collision [Post Condition]
@@ -827,29 +853,29 @@ public:
Vector3& outLocation,
Vector3& outNormal = ignore);
- /**
- Calculates time between the intersection of a moving sphere and a fixed
- sphere.
+ /** Calculates time between the intersection of a moving sphere
+ and a fixed sphere.
- @note This won't detect a collision if the sphere is already interpenetrating
- the fixed sphere.
-
- @param movingSphere Moving sphere.
- @param velocity Sphere's velocity.
- @param fixedSphere Fixed Sphere.
- @param location Location of collision -- not center position of sphere
- at the collision time. [Post Condition]
- @param outNormal Sphere's surface normal to collision [Post Condition]
-
- @return Time til collision. If there is no collision then the return
- value will be inf().
- */
- static float collisionTimeForMovingSphereFixedSphere(
- const class Sphere& sphere,
- const Vector3& velocity,
- const class Sphere& fixedSphere,
- Vector3& outLocation,
- Vector3& outNormal = ignore);
+ If they are already interpenetrating, returns 0 and @a
+ location is the closest point on the surface of the fixed sphere
+ to the center of the moving sphere.
+
+ @param sphere Moving sphere.
+ @param velocity Sphere's velocity.
+ @param fixedSphere Fixed Sphere.
+ @param outLocation Location of collision -- not center position of sphere
+ at the collision time. [Post Condition]
+ @param outNormal Moving sphere's surface normal to collision [Post Condition]
+
+ @return Time until collision. If there is no collision then the return
+ value will be inf().
+ */
+ static float collisionTimeForMovingSphereFixedSphere(
+ const Sphere& sphere,
+ const Vector3& velocity,
+ const Sphere& fixedSphere,
+ Vector3& outLocation,
+ Vector3& outNormal = ignore);
/**
Calculates time between the intersection of a moving sphere and a fixed
@@ -940,8 +966,8 @@ public:
and direction can be used in this function if already pre-calculated. This
prevents doing the same work twice.
- @param v0 line vertex 1.
- @param v1 line vertex 2.
+ @param v0 line vertex 0.
+ @param v1 line vertex 1.
@param edgeDirection The direction of the segment (unit length).
@param edgeLength The length of the segment.
@param point External point.
@@ -952,22 +978,22 @@ public:
const Vector3& v0,
const Vector3& v1,
const Vector3& edgeDirection,
- float edgeLength,
+ float edgeLength,
const Vector3& point);
/**
Finds the closest point on the perimeter of the triangle to an external point;
given a triangle defined by three points v0, v1, & v2, and the external point.
- @param v0 Triangle vertex 1.
- @param v1 Triangle vertex 2.
- @param v2 Triangle vertex 3.
+ @param v0 Triangle vertex 0.
+ @param v1 Triangle vertex 1.
+ @param v2 Triangle vertex 2.
@param point External point.
@return Closests point to point on the perimeter of the
triangle.
*/
- static Vector3 closestPointToTrianglePerimeter(
+ static Vector3 closestPointOnTrianglePerimeter(
const Vector3& v0,
const Vector3& v1,
const Vector3& v2,
@@ -982,42 +1008,56 @@ public:
and direction can be used in this function if already pre-calculated. This
prevents doing the same work twice.
- @param v0 Triangle vertex 1.
- @param v1 Triangle vertex 2.
- @param v2 Triangle vertex 3.
- @param point External point.
+ @param v Triangle vertices.
+ @param point External point.
+ @param edgeIndex The point lies on the edge between v[edgeIndex] and v[(edgeIndex + 1) % 3]
- @return Closests point to point on the perimeter of the
+ @return Closest point to point on the perimeter of the
triangle.
*/
- static Vector3 closestPointToTrianglePerimeter(
+ static Vector3 closestPointOnTrianglePerimeter(
const Vector3 v[3],
const Vector3 edgeDirection[3],
- const double edgeLength[3],
- const Vector3& point);
+ const float edgeLength[3],
+ const Vector3& point,
+ int& edgeIndex);
/**
Tests whether a point is contained within the triangle defined by
- v0, v1, & v2 and its plane's normal.
+ v0, v1, and v2 and its plane's normal.
- @param v0 Triangle vertex 1.
- @param v1 Triangle vertex 2.
- @param v2 Triangle vertex 3.
+ @param v0 Triangle vertex 0.
+ @param v1 Triangle vertex 1.
+ @param v2 Triangle vertex 2.
@param normal Normal to triangle's plane.
@param point The point in question.
@param primaryAxis Primary axis of triangle. This will be detected
if not given. This parameter is provided as an optimization.
+ @param b Barycentric coordinates; b[i] is the weight on v[i]
@return true - if point is inside the triangle.
@return false - otherwise
*/
static bool isPointInsideTriangle(
+ const Vector3& v0,
+ const Vector3& v1,
+ const Vector3& v2,
+ const Vector3& normal,
+ const Vector3& point,
+ float b[3],
+ Vector3::Axis primaryAxis = Vector3::DETECT_AXIS);
+
+ inline static bool isPointInsideTriangle(
const Vector3& v0,
const Vector3& v1,
const Vector3& v2,
const Vector3& normal,
const Vector3& point,
- Vector3::Axis primaryAxis = Vector3::DETECT_AXIS);
+ Vector3::Axis primaryAxis = Vector3::DETECT_AXIS) {
+
+ float b[3];
+ return isPointInsideTriangle(v0, v1, v2, normal, point, b, primaryAxis);
+ }
/**
Tests for the intersection of a moving sphere and a fixed box in a
@@ -1088,6 +1128,14 @@ public:
const Sphere& sphere,
const Box& box);
+ static bool fixedSolidSphereIntersectsFixedTriangle(
+ const Sphere& sphere,
+ const Triangle& triangle);
+
+ static bool fixedSolidBoxIntersectsFixedTriangle(
+ const AABox& box,
+ const Triangle& triangle);
+
/**
Tests whether a point is inside a rectangle defined by the vertexes
v0, v1, v2, & v3, and the rectangle's plane normal.
diff --git a/dep/include/g3dlite/G3D/Color1.h b/dep/include/g3dlite/G3D/Color1.h
new file mode 100644
index 000000000..0f68c84b3
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Color1.h
@@ -0,0 +1,144 @@
+/**
+ @file Color1.h
+
+ Monochrome Color class
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @created 2007-01-31
+ @edited 2009-03-20
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_COLOR1_H
+#define G3D_COLOR1_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/HashTrait.h"
+#include
+
+namespace G3D {
+
+/**
+ Monochrome color. This is just a float, but it has nice semantics
+ because a scaling by 255 automatically occurs when switching between
+ fixed point (Color1uint8) and floating point (Color1) formats.
+ */
+class Color1 {
+private:
+ // Hidden operators
+ bool operator<(const Color1&) const;
+ bool operator>(const Color1&) const;
+ bool operator<=(const Color1&) const;
+ bool operator>=(const Color1&) const;
+
+public:
+ float value;
+
+ /**
+ Initializes to 0
+ */
+ inline Color1() : value(0) {}
+
+ Color1(class BinaryInput& bi);
+
+ inline explicit Color1(float v) : value(v) {
+ }
+
+ inline bool isZero() const {
+ return value == 0.0f;
+ }
+
+ inline bool isOne() const {
+ return value == 1.0f;
+ }
+
+ static const Color1& one();
+
+ static const Color1& zero();
+
+ /** Returns the value three times */
+ class Color3 rgb() const;
+
+ Color1 (const class Color1uint8& other);
+
+ void serialize(class BinaryOutput& bo) const;
+ void deserialize(class BinaryInput& bi);
+
+ Color1 operator+ (const Color1& other) const {
+ return Color1(value + other.value);
+ }
+
+ Color1 operator+ (const float other) const {
+ return Color1(value + other);
+ }
+
+ Color1& operator+= (const Color1 other) {
+ value += other.value;
+ return *this;
+ }
+
+ Color1& operator-= (const Color1 other) {
+ value -= other.value;
+ return *this;
+ }
+
+ Color1 operator- (const Color1& other) const {
+ return Color1(value - other.value);
+ }
+
+ Color1 operator- (const float other) const {
+ return Color1(value - other);
+ }
+
+ Color1 operator- () const {
+ return Color1(-value);
+ }
+
+ Color1 operator* (const Color1& other) const {
+ return Color1(value * other.value);
+ }
+
+ Color1 operator* (const float other) const {
+ return Color1(value * other);
+ }
+
+ Color1 operator/ (const Color1& other) const {
+ return Color1(value / other.value);
+ }
+
+ Color1 operator/ (const float other) const {
+ return Color1(value / other);
+ }
+
+ inline Color1 max(const Color1& other) const {
+ return Color1(G3D::max(value, other.value));
+ }
+
+ inline Color1 min(const Color1& other) const {
+ return Color1(G3D::min(value, other.value));
+ }
+
+ inline Color1 lerp(const Color1& other, float a) const {
+ return Color1(value + (other.value - value) * a);
+
+ }
+
+ inline size_t hashCode() const {
+ return (size_t)(value * 0xFFFFFF);
+ }
+};
+
+}
+
+template <>
+struct HashTrait {
+ static size_t hashCode(const G3D::Color1& key) {
+ return key.hashCode();
+ }
+};
+
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Color1uint8.h b/dep/include/g3dlite/G3D/Color1uint8.h
new file mode 100644
index 000000000..092099d0d
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Color1uint8.h
@@ -0,0 +1,91 @@
+/**
+ @file Color1uint8.h
+
+ @maintainer Morgan McGuire, graphics3d.com
+
+ @created 2007-01-30
+ @edited 2007-01-30
+
+ Copyright 2000-2007, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_COLOR1UINT8_H
+#define G3D_COLOR1UINT8_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+
+namespace G3D {
+
+/**
+ Represents a Color1 as a packed integer. Convenient
+ for creating unsigned int vertex arrays.
+
+ WARNING: Integer color formats are different than
+ integer vertex formats. The color channels are automatically
+ scaled by 255 (because OpenGL automatically scales integer
+ colors back by this factor). So Color3(1,1,1) == Color3uint8(255,255,255)
+ but Vector3(1,1,1) == Vector3int16(1,1,1).
+
+ Note:
+ Conversion of a float32 to uint8 is accomplished by min(iFloor(f * 256)) and
+ back to float32 by u / 255.0f. This gives equal size intervals.
+Consider a number line from 0 to 1 and a corresponding one from 0 to 255. If we use iRound(x * 255), then the mapping for three critical intervals are:
+
+
+let s = 0.5/255
+ float int size
+[0, s) -> 0 s
+[s, s * 3) -> 1 2*s
+(1 - s, 1] -> 255 s
+
+
+If we use max(floor(x * 256), 255), then we get:
+
+
+let s = 1/256
+ float int size
+[0, s) -> 0 s
+[s, 2 * s) -> 1 s
+(1 - s, 1] -> 255 s
+
+and the intervals are all the same size, thus giving equal precision to all values.
+ */
+G3D_BEGIN_PACKED_CLASS(1)
+class Color1uint8 {
+private:
+ // Hidden operators
+ bool operator<(const Color1uint8&) const;
+ bool operator>(const Color1uint8&) const;
+ bool operator<=(const Color1uint8&) const;
+ bool operator>=(const Color1uint8&) const;
+
+public:
+
+ uint8 value;
+
+ Color1uint8() : value(0) {}
+
+ explicit Color1uint8(const uint8 _v) : value(_v) {}
+
+ Color1uint8(const class Color1& c);
+
+ Color1uint8(class BinaryInput& bi);
+
+ void serialize(class BinaryOutput& bo) const;
+
+ void deserialize(class BinaryInput& bi);
+
+ inline bool operator==(const Color1uint8& other) const {
+ return value == other.value;
+ }
+
+ inline bool operator!=(const Color1uint8& other) const {
+ return value != other.value;
+ }
+
+}
+G3D_END_PACKED_CLASS(1)
+}
+#endif
diff --git a/dep/include/g3dlite/G3D/Color3.h b/dep/include/g3dlite/G3D/Color3.h
new file mode 100644
index 000000000..bffe434fc
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Color3.h
@@ -0,0 +1,432 @@
+/**
+ @file Color3.h
+
+ Color class
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @cite Portions based on Dave Eberly's Magic Software Library
+ at http://www.magic-software.com
+
+ @created 2001-06-02
+ @edited 2009-04-28
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_Color3_h
+#define G3D_Color3_h
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/HashTrait.h"
+#include "G3D/Color1.h"
+#include
+
+namespace G3D {
+class Any;
+
+/**
+ Do not subclass-- this implementation makes assumptions about the
+ memory layout.
+ */
+class Color3 {
+private:
+ // Hidden operators
+ bool operator<(const Color3&) const;
+ bool operator>(const Color3&) const;
+ bool operator<=(const Color3&) const;
+ bool operator>=(const Color3&) const;
+
+public:
+ /**
+ Does not initialize fields.
+ */
+ Color3();
+
+ /** \param any Must be in one of the following forms:
+ - Color3(#, #, #)
+ - Color3::fromARGB(#)
+ - Color3{r = #, g = #, b = #)
+ - Color3::one()
+ - Color3::zero()
+ */
+ Color3(const Any& any);
+
+ /** Converts the Color3 to an Any. */
+ operator Any() const;
+
+ explicit Color3(class BinaryInput& bi);
+
+ Color3(float r, float g, float b);
+ Color3(float v) : r(v), g(v), b(v) {}
+
+ explicit Color3(const class Vector3& v);
+
+ explicit Color3(const float value[3]);
+
+ /** Returns this color */
+ const Color3& rgb() const {
+ return *this;
+ }
+
+ /**
+ Initialize from another color.
+ */
+ Color3 (const Color3& other);
+
+ Color3 (const class Color3uint8& other);
+
+ inline bool isZero() const {
+ return (r == 0.0f) && (g == 0.0f) && (b == 0.0f);
+ }
+
+ inline bool isOne() const {
+ return (r == 1.0f) && (g == 1.0f) && (b == 1.0f);
+ }
+
+ bool isFinite() const;
+
+ /**
+ Initialize from an HTML-style color (e.g. 0xFF0000 == RED)
+ */
+ static Color3 fromARGB(uint32);
+
+ /** Returns one of the color wheel colors (e.g. RED, GREEN, CYAN).
+ Does not include white, black, or gray. */
+ static const Color3& wheelRandom();
+
+ /** Generate colors according to the ANSI color set, mod 16.
+ \sa pastelMap */
+ static Color3 ansiMap(uint32 i);
+
+ /**
+ Generate colors using a hash such that adjacent values
+ are unlikely to have similar colors.
+
+ Useful for rendering with
+ stable but arbitrary colors, e.g., when debugging a mesh
+ algorithm.
+
+ \sa ansiMap
+ */
+ static Color3 pastelMap(uint32 i);
+
+ /**
+ * Channel value.
+ */
+ float r, g, b;
+
+ void serialize(class BinaryOutput& bo) const;
+ void deserialize(class BinaryInput& bi);
+
+ // access vector V as V[0] = V.r, V[1] = V.g, V[2] = V.b
+ //
+ // WARNING. These member functions rely on
+ // (1) Color3 not having virtual functions
+ // (2) the data packed in a 3*sizeof(float) memory block
+ const float& operator[] (int i) const;
+ float& operator[] (int i);
+
+ // assignment and comparison
+ Color3& operator= (const Color3& rkVector);
+ bool operator== (const Color3& rkVector) const;
+ bool operator!= (const Color3& rkVector) const;
+ size_t hashCode() const;
+
+ // arithmetic operations
+ Color3 operator+ (const Color3& rkVector) const;
+ Color3 operator- (const Color3& rkVector) const;
+ inline Color3 operator* (float s) const {
+ return Color3(r * s, g * s, b * s);
+ }
+ Color3 operator* (const Color3& rkVector) const;
+ inline Color3 operator/ (float fScalar) const {
+ return (*this) * (1.0f / fScalar);
+ }
+ Color3 operator- () const;
+
+ // arithmetic updates
+ Color3& operator+= (const Color3& rkVector);
+ Color3& operator-= (const Color3& rkVector);
+ Color3& operator*= (const Color3& rkVector);
+ Color3& operator*= (float fScalar);
+ Color3& operator/= (float fScalar);
+
+ bool fuzzyEq(const Color3& other) const;
+ bool fuzzyNe(const Color3& other) const;
+
+ // vector operations
+ float length () const;
+ Color3 direction() const;
+ float squaredLength () const;
+ float dot (const Color3& rkVector) const;
+ float unitize (float fTolerance = 1e-06);
+ Color3 cross (const Color3& rkVector) const;
+ Color3 unitCross (const Color3& rkVector) const;
+
+ inline Color3 pow(const Color3& other) const {
+ return Color3(::pow(r, other.r), ::pow(g, other.g), ::pow(b, other.b));
+ }
+
+ inline Color3 pow(float other) const {
+ return Color3(::pow(r, other), ::pow(g, other), ::pow(b, other));
+ }
+
+ inline Color3 max(const Color3& other) const {
+ return Color3(G3D::max(r, other.r), G3D::max(g, other.g), G3D::max(b, other.b));
+ }
+
+ inline Color3 min(const Color3& other) const {
+ return Color3(G3D::min(r, other.r), G3D::min(g, other.g), G3D::min(b, other.b));
+ }
+
+ /** Smallest element */
+ inline float min() const {
+ return G3D::min(G3D::min(r, g), b);
+ }
+
+ /** Largest element */
+ inline float max() const {
+ return G3D::max(G3D::max(r, g), b);
+ }
+
+ inline Color3 lerp(const Color3& other, float a) const {
+ return (*this) + (other - *this) * a;
+
+ }
+
+ inline float sum() const {
+ return r + g + b;
+ }
+
+ inline float average() const {
+ return sum() / 3.0f;
+ }
+
+
+ /**
+ * Converts from HSV to RGB , note: toHSV(fromHSV(_hsv)) may not be _hsv, if it is at a grey point or black point.
+ * The components of _hsv should lie in the unit interval.
+ * @cite Alvy Ray Smith SIGGRAPH 1978 "Color Gamut Transform Pairs"
+ **/
+ static Color3 fromHSV(const Vector3& _hsv);
+ static Vector3 toHSV(const Color3& _rgb);
+
+ /** Duplicates the matlab jet colormap maps [0,1] --> (r,g,b) where blue is close to 0 and red is close to 1. */
+ static Color3 jetColorMap(const float& val);
+
+ /** Returns colors with maximum saturation and value @param hue [0, 1]*/
+ static Color3 rainbowColorMap(float hue);
+
+ std::string toString() const;
+
+ /** Random unit vector */
+ static Color3 random();
+
+ // Special values.
+ // Intentionally not inlined: see Matrix3::identity() for details.
+ static const Color3& red();
+ static const Color3& green();
+ static const Color3& blue();
+ static const Color3& purple();
+ static const Color3& cyan();
+ static const Color3& yellow();
+ static const Color3& brown();
+ static const Color3& orange();
+ static const Color3& black();
+ static const Color3& gray();
+ static const Color3& white();
+
+ static const Color3& zero();
+ static const Color3& one();
+
+ inline Color3 bgr() const {
+ return Color3(b, g, r);
+ }
+};
+
+inline G3D::Color3 operator* (float s, const G3D::Color3& c) {
+ return c * s;
+}
+
+inline G3D::Color3 operator* (G3D::Color1& s, const G3D::Color3& c) {
+ return c * s.value;
+}
+
+inline G3D::Color3 operator* (const G3D::Color3& c, G3D::Color1& s) {
+ return c * s.value;
+}
+
+
+//----------------------------------------------------------------------------
+inline Color3::Color3 () {
+}
+
+//----------------------------------------------------------------------------
+
+inline Color3::Color3(float fX, float fY, float fZ) {
+ r = fX;
+ g = fY;
+ b = fZ;
+}
+
+//----------------------------------------------------------------------------
+inline Color3::Color3(const float afCoordinate[3]) {
+ r = afCoordinate[0];
+ g = afCoordinate[1];
+ b = afCoordinate[2];
+}
+
+//----------------------------------------------------------------------------
+inline Color3::Color3 (const Color3& rkVector) {
+ r = rkVector.r;
+ g = rkVector.g;
+ b = rkVector.b;
+}
+
+//----------------------------------------------------------------------------
+inline float& Color3::operator[] (int i) {
+ return ((float*)this)[i];
+}
+
+//----------------------------------------------------------------------------
+
+inline const float& Color3::operator[] (int i) const {
+ return ((float*)this)[i];
+}
+
+//----------------------------------------------------------------------------
+
+inline bool Color3::fuzzyEq(const Color3& other) const {
+ return G3D::fuzzyEq((*this - other).squaredLength(), 0);
+}
+
+//----------------------------------------------------------------------------
+
+inline bool Color3::fuzzyNe(const Color3& other) const {
+ return G3D::fuzzyNe((*this - other).squaredLength(), 0);
+}
+
+
+//----------------------------------------------------------------------------
+inline Color3& Color3::operator= (const Color3& rkVector) {
+ r = rkVector.r;
+ g = rkVector.g;
+ b = rkVector.b;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+inline bool Color3::operator== (const Color3& rkVector) const {
+ return ( r == rkVector.r && g == rkVector.g && b == rkVector.b );
+}
+
+//----------------------------------------------------------------------------
+inline bool Color3::operator!= (const Color3& rkVector) const {
+ return ( r != rkVector.r || g != rkVector.g || b != rkVector.b );
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::operator+ (const Color3& rkVector) const {
+ return Color3(r + rkVector.r, g + rkVector.g, b + rkVector.b);
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::operator- (const Color3& rkVector) const {
+ return Color3(r -rkVector.r, g - rkVector.g, b - rkVector.b);
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::operator* (const Color3& rkVector) const {
+ return Color3(r * rkVector.r, g * rkVector.g, b * rkVector.b);
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::operator- () const {
+ return Color3( -r, -g, -b);
+}
+
+//----------------------------------------------------------------------------
+inline Color3& Color3::operator+= (const Color3& rkVector) {
+ r += rkVector.r;
+ g += rkVector.g;
+ b += rkVector.b;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+inline Color3& Color3::operator-= (const Color3& rkVector) {
+ r -= rkVector.r;
+ g -= rkVector.g;
+ b -= rkVector.b;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+inline Color3& Color3::operator*= (float fScalar) {
+ r *= fScalar;
+ g *= fScalar;
+ b *= fScalar;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+inline Color3& Color3::operator*= (const Color3& rkVector) {
+ r *= rkVector.r;
+ g *= rkVector.g;
+ b *= rkVector.b;
+ return *this;
+}
+//----------------------------------------------------------------------------
+inline float Color3::squaredLength () const {
+ return r*r + g*g + b*b;
+}
+
+//----------------------------------------------------------------------------
+inline float Color3::length () const {
+ return sqrtf(r*r + g*g + b*b);
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::direction () const {
+ float lenSquared = r * r + g * g + b * b;
+
+ if (lenSquared != 1.0f) {
+ return *this / sqrtf(lenSquared);
+ } else {
+ return *this;
+ }
+}
+
+//----------------------------------------------------------------------------
+inline float Color3::dot (const Color3& rkVector) const {
+ return r*rkVector.r + g*rkVector.g + b*rkVector.b;
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::cross (const Color3& rkVector) const {
+ return Color3(g*rkVector.b - b*rkVector.g, b*rkVector.r - r*rkVector.b,
+ r*rkVector.g - g*rkVector.r);
+}
+
+//----------------------------------------------------------------------------
+inline Color3 Color3::unitCross (const Color3& rkVector) const {
+ Color3 kCross(g*rkVector.b - b*rkVector.g, b*rkVector.r - r*rkVector.b,
+ r*rkVector.g - g*rkVector.r);
+ kCross.unitize();
+ return kCross;
+}
+
+
+} // namespace
+
+
+template <> struct HashTrait {
+ static size_t hashCode(const G3D::Color3& key) {
+ return key.hashCode();
+ }
+};
+
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Color3uint8.h b/dep/include/g3dlite/G3D/Color3uint8.h
new file mode 100644
index 000000000..bd4b00d7f
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Color3uint8.h
@@ -0,0 +1,110 @@
+/**
+ @file Color3uint8.h
+
+ @maintainer Morgan McGuire, graphics3d.com
+
+ @created 2003-04-07
+ @edited 2006-06-24
+
+ Copyright 2000-2006, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_COLOR3UINT8_H
+#define G3D_COLOR3UINT8_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+
+namespace G3D {
+
+/**
+ Represents a Color3 as a packed integer. Convenient
+ for creating unsigned int vertex arrays. Used by
+ G3D::GImage as the underlying format.
+
+ WARNING: Integer color formats are different than
+ integer vertex formats. The color channels are automatically
+ scaled by 255 (because OpenGL automatically scales integer
+ colors back by this factor). So Color3(1,1,1) == Color3uint8(255,255,255)
+ but Vector3(1,1,1) == Vector3int16(1,1,1).
+ */
+
+G3D_BEGIN_PACKED_CLASS(1)
+
+class Color3uint8 {
+private:
+ // Hidden operators
+ bool operator<(const Color3uint8&) const;
+ bool operator>(const Color3uint8&) const;
+ bool operator<=(const Color3uint8&) const;
+ bool operator>=(const Color3uint8&) const;
+
+public:
+ uint8 r;
+ uint8 g;
+ uint8 b;
+
+ Color3uint8() : r(0), g(0), b(0) {}
+
+ Color3uint8(const uint8 _r, const uint8 _g, const uint8 _b) : r(_r), g(_g), b(_b) {}
+
+ Color3uint8(const class Color3& c);
+
+ Color3uint8(class BinaryInput& bi);
+
+ inline static Color3uint8 fromARGB(uint32 i) {
+ Color3uint8 c;
+ c.r = (i >> 16) & 0xFF;
+ c.g = (i >> 8) & 0xFF;
+ c.b = i & 0xFF;
+ return c;
+ }
+
+ inline Color3uint8 bgr() const {
+ return Color3uint8(b, g, r);
+ }
+
+ /**
+ Returns the color packed into a uint32
+ (the upper byte is 0xFF)
+ */
+ inline uint32 asUInt32() const {
+ return (0xFF << 24) + ((uint32)r << 16) + ((uint32)g << 8) + b;
+ }
+
+ void serialize(class BinaryOutput& bo) const;
+
+ void deserialize(class BinaryInput& bi);
+
+ // access vector V as V[0] = V.r, V[1] = V.g, V[2] = V.b
+ //
+ // WARNING. These member functions rely on
+ // (1) Color3 not having virtual functions
+ // (2) the data packed in a 3*sizeof(uint8) memory block
+ uint8& operator[] (int i) const {
+ debugAssert((unsigned int)i < 3);
+ return ((uint8*)this)[i];
+ }
+
+ operator uint8* () {
+ return (G3D::uint8*)this;
+ }
+
+ operator const uint8* () const {
+ return (uint8*)this;
+ }
+
+ bool operator==(const Color3uint8& other) const {
+ return (other.r == r) && (other.g == g) && (other.b == b);
+ }
+
+ bool operator!=(const Color3uint8& other) const {
+ return (other.r != r) && (other.g != g) && (other.b != b);
+ }
+}
+G3D_END_PACKED_CLASS(1)
+
+} // namespace G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Color4.h b/dep/include/g3dlite/G3D/Color4.h
new file mode 100644
index 000000000..d8858abbc
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Color4.h
@@ -0,0 +1,338 @@
+/**
+ @file Color4.h
+
+ Color class
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @cite Portions based on Dave Eberly's Magic Software Library
+ at http://www.magic-software.com
+
+ @created 2002-06-25
+ @edited 2009-11-15
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_Color4_h
+#define G3D_Color4_h
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/Color3.h"
+#include
+
+namespace G3D {
+
+class Any;
+
+/**
+ Do not subclass-- this implementation makes assumptions about the
+ memory layout.
+ */
+class Color4 {
+private:
+ // Hidden operators
+ bool operator<(const Color4&) const;
+ bool operator>(const Color4&) const;
+ bool operator<=(const Color4&) const;
+ bool operator>=(const Color4&) const;
+
+public:
+
+ /** \param any Must be in one of the following forms:
+ - Color4(#, #, #, #)
+ - Color4::fromARGB(#)
+ - Color4{r = #, g = #, b = #, a = #)
+ */
+ Color4(const Any& any);
+
+ /** Converts the Color4 to an Any. */
+ operator Any() const;
+
+ /**
+ * Does not initialize fields.
+ */
+ Color4 ();
+
+ Color4(const Color3& c3, float a = 1.0);
+
+ Color4(const class Color4uint8& c);
+
+ Color4(class BinaryInput& bi);
+
+ Color4(const class Vector4& v);
+
+ Color4(float r, float g, float b, float a = 1.0);
+
+ static const Color4& one();
+
+ Color4(float value[4]);
+
+ /**
+ * Initialize from another color.
+ */
+ Color4(const Color4& other);
+
+
+ inline bool isZero() const {
+ return (r == 0.0f) && (g == 0.0f) && (b == 0.0f) && (a == 0.0f);
+ }
+
+ inline bool isOne() const {
+ return (r == 1.0f) && (g == 1.0f) && (b == 1.0f) && (a == 1.0f);
+ }
+
+ void serialize(class BinaryOutput& bo) const;
+ void deserialize(class BinaryInput& bi);
+
+ /**
+ Initialize from an HTML-style color (e.g. 0xFFFF0000 == RED)
+ */
+ static Color4 fromARGB(uint32);
+
+ /**
+ * Channel values.
+ */
+ float r, g, b, a;
+
+ inline Color3 rgb() const {
+ return Color3(r, g, b);
+ }
+
+ // access vector V as V[0] = V.r, V[1] = V.g, V[2] = V.b, v[3] = V.a
+ //
+ // WARNING. These member functions rely on
+ // (1) Color4 not having virtual functions
+ // (2) the data packed in a 3*sizeof(float) memory block
+ float& operator[] (int i) const;
+
+ // assignment and comparison
+ Color4& operator= (const Color4& rkVector);
+ bool operator== (const Color4& rkVector) const;
+ bool operator!= (const Color4& rkVector) const;
+ size_t hashCode() const;
+
+ // arithmetic operations
+ Color4 operator+ (const Color4& rkVector) const;
+ Color4 operator- (const Color4& rkVector) const;
+ Color4 operator* (float fScalar) const;
+ inline Color4 operator* (const Color4& k) const {
+ return Color4(r*k.r, g*k.g, b*k.b, a * k.a);
+ }
+ Color4 operator/ (float fScalar) const;
+ Color4 operator- () const;
+ friend Color4 operator* (double fScalar, const Color4& rkVector);
+
+ // arithmetic updates
+ Color4& operator+= (const Color4& rkVector);
+ Color4& operator-= (const Color4& rkVector);
+ Color4& operator*= (float fScalar);
+ Color4& operator/= (float fScalar);
+
+ bool fuzzyEq(const Color4& other) const;
+ bool fuzzyNe(const Color4& other) const;
+
+ std::string toString() const;
+
+ inline Color4 max(const Color4& other) const {
+ return Color4(G3D::max(r, other.r), G3D::max(g, other.g), G3D::max(b, other.b), G3D::max(a, other.a));
+ }
+
+ inline Color4 min(const Color4& other) const {
+ return Color4(G3D::min(r, other.r), G3D::min(g, other.g), G3D::min(b, other.b), G3D::min(a, other.a));
+ }
+
+ /** r + g + b + a */
+ inline float sum() const {
+ return r + g + b + a;
+ }
+
+ inline Color4 lerp(const Color4& other, float a) const {
+ return (*this) + (other - *this) * a;
+
+ }
+
+ // Special values.
+ // Intentionally not inlined: see Matrix3::identity() for details.
+ static const Color4& zero();
+ static const Color4& clear();
+
+ static const Color4& inf();
+ static const Color4& nan();
+
+ inline bool isFinite() const {
+ return G3D::isFinite(r) && G3D::isFinite(g) && G3D::isFinite(b) && G3D::isFinite(a);
+ }
+
+ inline Color3 bgr() const {
+ return Color3(b, g, r);
+ }
+};
+
+/**
+ Extends the c3 with alpha = 1.0
+ */
+Color4 operator*(const Color3& c3, const Color4& c4);
+
+
+inline Color4 operator*(const Color3& c3, const Color4& c4) {
+ return Color4(c3.r * c4.r, c3.g * c4.g, c3.b * c4.b, c4.a);
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4::Color4 () {
+ // For efficiency in construction of large arrays of vectors, the
+ // default constructor does not initialize the vector.
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4::Color4(const Color3& c3, float a) {
+ r = c3.r;
+ g = c3.g;
+ b = c3.b;
+ this->a = a;
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4::Color4(
+ float r,
+ float g,
+ float b,
+ float a) :
+ r(r), g(g), b(b), a(a) {
+}
+
+//----------------------------------------------------------------------------
+inline Color4::Color4 (float afCoordinate[4]) {
+ r = afCoordinate[0];
+ g = afCoordinate[1];
+ b = afCoordinate[2];
+ a = afCoordinate[3];
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4::Color4(
+ const Color4& other) {
+
+ r = other.r;
+ g = other.g;
+ b = other.b;
+ a = other.a;
+}
+
+//----------------------------------------------------------------------------
+
+inline float& Color4::operator[] (int i) const {
+ return ((float*)this)[i];
+}
+
+//----------------------------------------------------------------------------
+
+inline bool Color4::fuzzyEq(const Color4& other) const {
+ Color4 dif = (*this - other);
+ return G3D::fuzzyEq(dif.r * dif.r + dif.g * dif.g + dif.b * dif.b + dif.a * dif.a, 0);
+}
+
+//----------------------------------------------------------------------------
+
+inline bool Color4::fuzzyNe(const Color4& other) const {
+ Color4 dif = (*this - other);
+ return G3D::fuzzyNe(dif.r * dif.r + dif.g * dif.g + dif.b * dif.b + dif.a * dif.a, 0);
+}
+
+
+//----------------------------------------------------------------------------
+inline Color4& Color4::operator= (const Color4& other) {
+ r = other.r;
+ g = other.g;
+ b = other.b;
+ a = other.a;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+
+inline bool Color4::operator== (const Color4& other) const {
+ return ( r == other.r && g == other.g && b == other.b && a == other.a);
+}
+
+//----------------------------------------------------------------------------
+
+inline bool Color4::operator!= (const Color4& other) const {
+ return ( r != other.r || g != other.g || b != other.b || a != other.a);
+}
+
+//----------------------------------------------------------------------------
+inline Color4 Color4::operator+ (const Color4& other) const {
+ return Color4(r + other.r, g + other.g, b + other.b, a + other.a);
+}
+
+//----------------------------------------------------------------------------
+inline Color4 Color4::operator- (const Color4& other) const {
+ return Color4(r - other.r, g - other.g, b - other.b, a - other.a);
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4 Color4::operator* (float fScalar) const {
+ return Color4(fScalar * r, fScalar * g, fScalar * b, fScalar * a);
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4 Color4::operator- () const {
+ return Color4(-r, -g, -b, -a);
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4 operator* (float fScalar, const Color4& other) {
+ return Color4(fScalar * other.r, fScalar * other.g,
+ fScalar * other.b, fScalar * other.a);
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4& Color4::operator+= (const Color4& other) {
+ r += other.r;
+ g += other.g;
+ b += other.b;
+ a += other.a;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4& Color4::operator-= (const Color4& other) {
+ r -= other.r;
+ g -= other.g;
+ b -= other.b;
+ a -= other.a;
+ return *this;
+}
+
+//----------------------------------------------------------------------------
+
+inline Color4& Color4::operator*= (float fScalar) {
+ r *= fScalar;
+ g *= fScalar;
+ b *= fScalar;
+ a *= fScalar;
+ return *this;
+}
+
+} // namespace
+
+template <>
+struct HashTrait {
+ static size_t hashCode(const G3D::Color4& key) {
+ return key.hashCode();
+ }
+};
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Color4uint8.h b/dep/include/g3dlite/G3D/Color4uint8.h
new file mode 100644
index 000000000..ab8c07292
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Color4uint8.h
@@ -0,0 +1,115 @@
+/**
+ @file Color4uint8.h
+
+ @maintainer Morgan McGuire, graphics3d.com
+
+ @created 2003-04-07
+ @edited 2006-03-24
+
+ Copyright 2000-2006, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef COLOR4UINT8_H
+#define COLOR4UINT8_H
+
+#include "G3D/g3dmath.h"
+#include "G3D/platform.h"
+#include "G3D/Color3uint8.h"
+
+namespace G3D {
+
+/**
+ Represents a Color4 as a packed integer. Convenient
+ for creating unsigned int vertex arrays. Used by
+ G3D::GImage as the underlying format.
+
+ WARNING: Integer color formats are different than
+ integer vertex formats. The color channels are automatically
+ scaled by 255 (because OpenGL automatically scales integer
+ colors back by this factor). So Color4(1,1,1) == Color4uint8(255,255,255)
+ but Vector3(1,1,1) == Vector3int16(1,1,1).
+
+ */
+G3D_BEGIN_PACKED_CLASS(1)
+class Color4uint8 {
+private:
+ // Hidden operators
+ bool operator<(const Color4uint8&) const;
+ bool operator>(const Color4uint8&) const;
+ bool operator<=(const Color4uint8&) const;
+ bool operator>=(const Color4uint8&) const;
+
+public:
+ uint8 r;
+ uint8 g;
+ uint8 b;
+ uint8 a;
+
+ Color4uint8() : r(0), g(0), b(0), a(0) {}
+
+ Color4uint8(const class Color4& c);
+
+ Color4uint8(const uint8 _r, const uint8 _g, const uint8 _b, const uint8 _a) : r(_r), g(_g), b(_b), a(_a) {}
+
+ Color4uint8(const Color3uint8& c, const uint8 _a) : r(c.r), g(c.g), b(c.b), a(_a) {}
+
+ Color4uint8(class BinaryInput& bi);
+
+ inline static Color4uint8 fromARGB(uint32 i) {
+ Color4uint8 c;
+ c.a = (i >> 24) & 0xFF;
+ c.r = (i >> 16) & 0xFF;
+ c.g = (i >> 8) & 0xFF;
+ c.b = i & 0xFF;
+ return c;
+ }
+
+ inline uint32 asUInt32() const {
+ return ((uint32)a << 24) + ((uint32)r << 16) + ((uint32)g << 8) + b;
+ }
+
+ // access vector V as V[0] = V.r, V[1] = V.g, V[2] = V.b
+ //
+ // WARNING. These member functions rely on
+ // (1) Color4uint8 not having virtual functions
+ // (2) the data packed in a 3*sizeof(uint8) memory block
+ uint8& operator[] (int i) const {
+ return ((uint8*)this)[i];
+ }
+
+ operator uint8* () {
+ return (uint8*)this;
+ }
+
+ operator const uint8* () const {
+ return (uint8*)this;
+ }
+
+
+ inline Color3uint8 bgr() const {
+ return Color3uint8(b, g, r);
+ }
+
+ void serialize(class BinaryOutput& bo) const;
+
+ void deserialize(class BinaryInput& bi);
+
+ inline Color3uint8 rgb() const {
+ return Color3uint8(r, g, b);
+ }
+
+ bool operator==(const Color4uint8& other) const {
+ return *reinterpret_cast(this) == *reinterpret_cast(&other);
+ }
+
+ bool operator!=(const Color4uint8& other) const {
+ return *reinterpret_cast(this) != *reinterpret_cast(&other);
+ }
+
+}
+G3D_END_PACKED_CLASS(1)
+
+} // namespace G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Cone.h b/dep/include/g3dlite/G3D/Cone.h
new file mode 100644
index 000000000..d801a9b34
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Cone.h
@@ -0,0 +1,68 @@
+/**
+ @file Cone.h
+
+ Cone class
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @cite Portions based on Dave Eberly's Magic Software Library at http://www.magic-software.com
+
+ @created 2001-06-02
+ @edited 2006-02-23
+
+ Copyright 2000-2006, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_CONE_H
+#define G3D_CONE_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/Vector3.h"
+
+namespace G3D {
+
+/**
+ An infinite cone.
+ */
+class Cone {
+
+private:
+ Vector3 tip;
+ Vector3 direction;
+
+ /** Angle from the center line to the edge. */
+ float angle;
+
+public:
+
+ /**
+ @param angle Angle from the center line to the edge, in radians
+ */
+ Cone(const Vector3& tip, const Vector3& direction, float angle);
+
+ /**
+ Forms the smallest cone that contains the box. Undefined if
+ the tip is inside or on the box.
+ */
+ Cone(const Vector3& tip, const class Box& box);
+
+ virtual ~Cone() {}
+
+ /**
+ Returns true if the cone touches, intersects, or contains b.
+
+ If c.intersects(s) and c.intersects(Sphere(s.center, s.radius * 2)
+ then the sphere s is entirely within cone c.
+ */
+ bool intersects(const class Sphere& s) const;
+
+ /**
+ True if v is a point inside the cone.
+ */
+ bool contains(const class Vector3& v) const;
+};
+
+} // namespace
+
+#endif
diff --git a/dep/include/g3dlite/G3D/ConvexPolyhedron.h b/dep/include/g3dlite/G3D/ConvexPolyhedron.h
new file mode 100644
index 000000000..a6fdd62cf
--- /dev/null
+++ b/dep/include/g3dlite/G3D/ConvexPolyhedron.h
@@ -0,0 +1,180 @@
+/**
+ @file ConvexPolyhedron.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2001-11-11
+ @edited 2006-04-10
+
+ Copyright 2000-2006, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_CONVEXPOLYHEDRON_H
+#define G3D_CONVEXPOLYHEDRON_H
+
+#include "G3D/platform.h"
+#include "G3D/Vector3.h"
+#include "G3D/Vector2.h"
+#include "G3D/CoordinateFrame.h"
+#include "G3D/Plane.h"
+#include "G3D/Line.h"
+#include "G3D/Array.h"
+
+namespace G3D {
+
+class DirectedEdge {
+public:
+ Vector3 start;
+ Vector3 stop;
+};
+
+class ConvexPolygon {
+private:
+
+ friend class ConvexPolyhedron;
+
+ Array _vertex;
+
+public:
+
+ ConvexPolygon() {}
+ ConvexPolygon(const Vector3& v0, const Vector3& v1, const Vector3& v2);
+ ConvexPolygon(const Array& __vertex);
+ virtual ~ConvexPolygon() {}
+
+ /**
+ Counter clockwise winding order.
+ */
+ inline const Vector3& vertex(int i) const {
+ return _vertex[i];
+ }
+
+ inline void setVertex(int i, const Vector3& v) {
+ _vertex[i] = v;
+ }
+
+ /**
+ Zero vertices indicates an empty polygon (zero area).
+ */
+ inline int numVertices() const {
+ return _vertex.size();
+ }
+
+ inline void setNumVertices(int n) {
+ _vertex.resize(n);
+ }
+
+ /**
+ O(n) in the number of edges
+ */
+ bool isEmpty() const;
+
+ /**
+ Cuts the polygon at the plane. If the polygon is entirely above or below
+ the plane, one of the returned polygons will be empty.
+
+ @param above The part of the polygon above (on the side the
+ normal points to or in the plane) the plane
+ @param below The part of the polygon below the plane.
+ @param newEdge If a new edge was introduced, this is that edge (on the above portion; the below portion is the opposite winding.
+ */
+ void cut(const Plane& plane, ConvexPolygon &above, ConvexPolygon &below, DirectedEdge& newEdge);
+ void cut(const Plane& plane, ConvexPolygon &above, ConvexPolygon &below);
+
+ /**
+ When a cut plane grazes a vertex in the polygon, two near-identical vertices may be created.
+ The closeness of these two points can cause a number of problems, such as ConvexPolygon::normal()
+ returning an infinite vector. It should be noted, however, that not all applications are
+ sensitive to near-identical vertices.
+
+ removeDuplicateVertices() detects and eliminates redundant vertices.
+ */
+ void removeDuplicateVertices();
+
+ /**
+ O(n) in the number of edges
+ */
+ float getArea() const;
+
+ inline Vector3 normal() const {
+ debugAssert(_vertex.length() >= 3);
+ return (_vertex[1] - _vertex[0]).cross(_vertex[2] - _vertex[0]).direction();
+ }
+
+ /**
+ Returns the same polygon with inverse winding.
+ */
+ ConvexPolygon inverse() const;
+};
+
+
+
+class ConvexPolyhedron {
+public:
+ /**
+ Zero faces indicates an empty polyhedron
+ */
+ Array face;
+
+ ConvexPolyhedron() {}
+ ConvexPolyhedron(const Array& _face);
+
+ /**
+ O(n) in the number of edges
+ */
+ bool isEmpty() const;
+
+ /**
+ O(n) in the number of edges
+ */
+ float getVolume() const;
+
+ /**
+ Cuts the polyhedron at the plane. If the polyhedron is entirely above or below
+ the plane, one of the returned polyhedra will be empty.
+
+ @param above The part of the polyhedron above (on the side the
+ normal points to or in the plane) the plane
+ @param below The part of the polyhedron below the plane.
+ */
+ void cut(const Plane& plane, ConvexPolyhedron &above, ConvexPolyhedron &below);
+};
+
+/**
+
+ */
+class ConvexPolygon2D {
+private:
+
+ Array m_vertex;
+
+public:
+
+ ConvexPolygon2D() {}
+
+ /**
+ Points are counter-clockwise in a Y = down, X = right coordinate
+ system.
+
+ @param reverse If true, the points are reversed (i.e. winding direction is changed)
+ before the polygon is created.
+ */
+ ConvexPolygon2D(const Array& pts, bool reverse = false);
+
+ inline int numVertices() const {
+ return m_vertex.size();
+ }
+
+ inline const Vector2& vertex(int index) const {
+ debugAssert((index >= 0) && (index <= m_vertex.size()));
+ return m_vertex[index];
+ }
+
+ /** @param reverseWinding If true, the winding direction of the polygon is reversed for this test.*/
+ bool contains(const Vector2& p, bool reverseWinding = false) const;
+};
+
+
+} // namespace
+#endif
diff --git a/dep/include/g3dlite/G3D/CoordinateFrame.h b/dep/include/g3dlite/G3D/CoordinateFrame.h
index 657323eea..7ed4d0acc 100644
--- a/dep/include/g3dlite/G3D/CoordinateFrame.h
+++ b/dep/include/g3dlite/G3D/CoordinateFrame.h
@@ -1,17 +1,17 @@
/**
@file CoordinateFrame.h
- @maintainer Morgan McGuire, matrix@graphics3d.com
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
@created 2001-03-04
- @edited 2006-04-07
+ @edited 2009-04-29
- Copyright 2000-2006, Morgan McGuire.
+ Copyright 2000-2009, Morgan McGuire.
All rights reserved.
*/
-#ifndef G3D_COORDINATEFRAME_H
-#define G3D_COORDINATEFRAME_H
+#ifndef G3D_CFrame_h
+#define G3D_CFrame_h
#include "G3D/platform.h"
#include "G3D/Vector3.h"
@@ -24,7 +24,15 @@
#include
#include
+#ifdef _MSC_VER
+// Turn off "conditional expression is constant" warning; MSVC generates this
+// for debug assertions in inlined methods.
+# pragma warning (disable : 4127)
+#endif
+
+
namespace G3D {
+class Any;
/**
A rigid body RT (rotation-translation) transformation.
@@ -45,26 +53,26 @@ Convert to Matrix4 using CoordinateFrame::toMatrix4. You can construct a
from a Matrix4 using Matrix4::approxCoordinateFrame, however, because a Matrix4 is more
general than a CoordinateFrame, some information may be lost.
-See also: G3D::Matrix4, G3D::Quat
+@sa G3D::UprightFrame, G3D::PhysicsFrame, G3D::Matrix4, G3D::Quat
*/
class CoordinateFrame {
public:
- /**
- Takes object space points to world space.
- */
+ /** Takes object space points to world space. */
Matrix3 rotation;
- /**
- Takes object space points to world space.
- */
+ /** Takes object space points to world space. */
Vector3 translation;
- /**
- The direction an object "looks" relative to its own axes.
- @deprecated This is always -1 and will be fixed at that value in future releases.
- */
- static const float zLookDirection;
+ /** \param any Must be in one of the following forms:
+ - CFrame((matrix3 expr), (vector3 expr))
+ - CFrame::fromXYZYPRDegrees(#, #, #, #, #, #)
+ - CFrame { rotation = (matrix3 expr), translation = (vector3 expr) }
+ */
+ CoordinateFrame(const Any& any);
+
+ /** Converts the CFrame to an Any. */
+ operator Any() const;
inline bool operator==(const CoordinateFrame& other) const {
return (translation == other.translation) && (rotation == other.rotation);
@@ -83,14 +91,12 @@ public:
/**
Initializes to the identity coordinate frame.
*/
- inline CoordinateFrame() :
- rotation(Matrix3::identity()), translation(Vector3::zero()) {
- }
+ CoordinateFrame();
- CoordinateFrame(const Vector3& _translation) :
+ CoordinateFrame(const Vector3& _translation) :
rotation(Matrix3::identity()), translation(_translation) {
- }
-
+ }
+
CoordinateFrame(const Matrix3 &rotation, const Vector3 &translation) :
rotation(rotation), translation(translation) {
}
@@ -99,6 +105,23 @@ public:
rotation(rotation), translation(Vector3::zero()) {
}
+ CoordinateFrame(const class UprightFrame& f);
+
+ static CoordinateFrame fromXYZYPRRadians(float x, float y, float z, float yaw = 0.0f, float pitch = 0.0f, float roll = 0.0f);
+
+ /** Construct a coordinate frame from translation = (x,y,z) and
+ rotations (in that order) about Y, object space X, object space
+ Z. Note that because object-space axes are used, these are not
+ equivalent to Euler angles; they are known as Tait-Bryan
+ rotations and are more convenient for intuitive positioning.*/
+ static CoordinateFrame fromXYZYPRDegrees(float x, float y, float z, float yaw = 0.0f, float pitch = 0.0f, float roll = 0.0f);
+
+ CoordinateFrame(class BinaryInput& b);
+
+ void deserialize(class BinaryInput& b);
+
+ void serialize(class BinaryOutput& b) const;
+
CoordinateFrame(const CoordinateFrame &other) :
rotation(other.rotation), translation(other.translation) {}
@@ -117,8 +140,13 @@ public:
/** See also Matrix4::approxCoordinateFrame */
class Matrix4 toMatrix4() const;
+ void getXYZYPRRadians(float& x, float& y, float& z, float& yaw, float& pitch, float& roll) const;
+ void getXYZYPRDegrees(float& x, float& y, float& z, float& yaw, float& pitch, float& roll) const;
+
+
/**
Produces an XML serialization of this coordinate frame.
+ @deprecated
*/
std::string toXML() const;
@@ -131,7 +159,7 @@ public:
object has an inverted heading.
*/
inline float getHeading() const {
- Vector3 look = rotation.getColumn(2);
+ Vector3 look = rotation.column(2);
float angle = -(float) atan2(-look.x, look.z);
return angle;
}
@@ -163,17 +191,18 @@ public:
}
/**
- Transforms the point into object space.
+ Transforms the point into object space. Assumes that the rotation matrix is orthonormal.
*/
- inline Vector3 pointToObjectSpace(const Vector3& v) const {
- float p[3];
- p[0] = v[0] - translation[0];
- p[1] = v[1] - translation[1];
- p[2] = v[2] - translation[2];
- return Vector3(
- rotation[0][0] * p[0] + rotation[1][0] * p[1] + rotation[2][0] * p[2],
- rotation[0][1] * p[0] + rotation[1][1] * p[1] + rotation[2][1] * p[2],
- rotation[0][2] * p[0] + rotation[1][2] * p[1] + rotation[2][2] * p[2]);
+ inline Vector3 pointToObjectSpace(const Vector3& v) const {
+ float p[3];
+ p[0] = v[0] - translation[0];
+ p[1] = v[1] - translation[1];
+ p[2] = v[2] - translation[2];
+ debugAssert(G3D::fuzzyEq(rotation.determinant(), 1.0f));
+ return Vector3(
+ rotation[0][0] * p[0] + rotation[1][0] * p[1] + rotation[2][0] * p[2],
+ rotation[0][1] * p[0] + rotation[1][1] * p[1] + rotation[2][1] * p[2],
+ rotation[0][2] * p[0] + rotation[1][2] * p[1] + rotation[2][2] * p[2]);
}
/**
@@ -260,14 +289,9 @@ public:
const Vector3& target,
Vector3 up);
- /** @deprecated See lookVector */
- inline Vector3 getLookVector() const {
- return rotation.getColumn(2) * zLookDirection;
- }
-
/** The direction this camera is looking (its negative z axis)*/
inline Vector3 lookVector() const {
- return rotation.getColumn(2) * zLookDirection;
+ return -rotation.column(2);
}
/** Returns the ray starting at the camera origin travelling in direction CoordinateFrame::lookVector. */
@@ -275,20 +299,11 @@ public:
/** Up direction for this camera (its y axis). */
inline Vector3 upVector() const {
- return rotation.getColumn(1);
+ return rotation.column(1);
}
- /**
- If a viewer looks along the look vector, this is the viewer's "left"
- @deprecated leftVector
- */
- inline Vector3 getLeftVector() const {
- return -rotation.getColumn(0);
- }
-
- /** @deprecated See rightVector */
- inline Vector3 getRightVector() const {
- return rotation.getColumn(0);
+ inline Vector3 rightVector() const {
+ return rotation.column(0);
}
/**
@@ -296,11 +311,7 @@ public:
Useful for strafing motions and building alternative coordinate frames.
*/
inline Vector3 leftVector() const {
- return -rotation.getColumn(0);
- }
-
- inline Vector3 rightVector() const {
- return rotation.getColumn(0);
+ return -rotation.column(0);
}
/**
@@ -313,6 +324,8 @@ public:
};
+typedef CoordinateFrame CFrame;
+
} // namespace
#endif
diff --git a/dep/include/g3dlite/G3D/Crypto.h b/dep/include/g3dlite/G3D/Crypto.h
index f4e7bfad6..56c816a49 100644
--- a/dep/include/g3dlite/G3D/Crypto.h
+++ b/dep/include/g3dlite/G3D/Crypto.h
@@ -1,7 +1,7 @@
/**
@file Crypto.h
- @maintainer Morgan McGuire, matrix@graphics3d.com
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
@created 2006-03-29
@@ -17,6 +17,48 @@
namespace G3D {
+/** See G3D::Crypto::md5 */
+class MD5Hash {
+private:
+
+ uint8 value[16];
+
+public:
+
+ MD5Hash() {
+ for (int i = 0; i < 16; ++i) {
+ value[i] = 0;
+ }
+ }
+
+ explicit MD5Hash(class BinaryInput& b);
+
+ uint8& operator[](int i) {
+ return value[i];
+ }
+
+ const uint8& operator[](int i) const {
+ return value[i];
+ }
+
+ bool operator==(const MD5Hash& other) const {
+ bool match = true;
+ for (int i = 0; i < 16; ++i) {
+ match = match && (other.value[i] == value[i]);
+ }
+ return match;
+ }
+
+ inline bool operator!=(const MD5Hash& other) const {
+ return !(*this == other);
+ }
+
+ void deserialize(class BinaryInput& b);
+
+ void serialize(class BinaryOutput& b) const;
+};
+
+
/** Cryptography and hashing helper functions */
class Crypto {
public:
@@ -31,6 +73,14 @@ public:
*/
static uint32 crc32(const void* bytes, size_t numBytes);
+ /**
+ Computes the MD5 hash (message digest) of a byte stream, as defined by
+ http://www.ietf.org/rfc/rfc1321.txt.
+
+ @cite Based on implementation by L. Peter Deutsch, ghost@aladdin.com
+ */
+ MD5Hash md5(const void* bytes, size_t numBytes);
+
/**
Returns the nth prime less than 2000 in constant time. The first prime has index
0 and is the number 2.
diff --git a/dep/include/g3dlite/G3D/Cylinder.h b/dep/include/g3dlite/G3D/Cylinder.h
new file mode 100644
index 000000000..85eba77b7
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Cylinder.h
@@ -0,0 +1,92 @@
+/**
+ @file Cylinder.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-02-07
+ @edited 2005-09-26
+
+ Copyright 2000-2005, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_Cylinder_H
+#define G3D_Cylinder_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/Vector3.h"
+
+namespace G3D {
+
+class Line;
+class AABox;
+/**
+ Right cylinder
+ */
+class Cylinder {
+private:
+ Vector3 p1;
+ Vector3 p2;
+
+ float mRadius;
+
+public:
+
+ /** Uninitialized */
+ Cylinder();
+ Cylinder(class BinaryInput& b);
+ Cylinder(const Vector3& _p1, const Vector3& _p2, float _r);
+ void serialize(class BinaryOutput& b) const;
+ void deserialize(class BinaryInput& b);
+
+ /** The line down the center of the Cylinder */
+ Line axis() const;
+
+ /**
+ A reference frame in which the center of mass is at the origin and
+ the Y-axis is the cylinder's axis. If the cylinder is transformed, this reference frame
+ may freely rotate around its axis.*/
+ void getReferenceFrame(class CoordinateFrame& cframe) const;
+
+ /** Returns point 0 or 1 */
+ inline const Vector3& point(int i) const {
+ debugAssert(i >= 0 && i <= 1);
+ return (i == 0) ? p1 : p2;
+ }
+
+ /**
+ Returns true if the point is inside the Cylinder or on its surface.
+ */
+ bool contains(const Vector3& p) const;
+
+ float area() const;
+
+ float volume() const;
+
+ float radius() const;
+
+ /** Center of mass */
+ inline Vector3 center() const {
+ return (p1 + p2) / 2.0f;
+ }
+
+ inline float height() const {
+ return (p1 - p2).magnitude();
+ }
+
+ /**
+ Get close axis aligned bounding box.
+ With vertical world orientation, the top and bottom might not be very tight. */
+ void getBounds(AABox& out) const;
+
+ /** Random world space point with outward facing normal. */
+ void getRandomSurfacePoint(Vector3& P, Vector3& N) const;
+
+ /** Point selected uniformly at random over the volume. */
+ Vector3 randomInteriorPoint() const;
+};
+
+} // namespace
+
+#endif
diff --git a/dep/include/g3dlite/G3D/EqualsTrait.h b/dep/include/g3dlite/G3D/EqualsTrait.h
new file mode 100644
index 000000000..349cb5088
--- /dev/null
+++ b/dep/include/g3dlite/G3D/EqualsTrait.h
@@ -0,0 +1,26 @@
+/**
+ @file EqualsTrait.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @created 2008-10-01
+ @edited 2008-10-01
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_EQUALSTRAIT_H
+#define G3D_EQUALSTRAIT_H
+
+#include "G3D/platform.h"
+
+/** Default implementation of EqualsTrait.
+ @see G3D::Table for specialization requirements.
+*/
+template struct EqualsTrait {
+ static bool equals(const Key& a, const Key& b) {
+ return a == b;
+ }
+};
+
+#endif
+
diff --git a/dep/include/g3dlite/G3D/G3D.h b/dep/include/g3dlite/G3D/G3D.h
new file mode 100644
index 000000000..5b56b9c71
--- /dev/null
+++ b/dep/include/g3dlite/G3D/G3D.h
@@ -0,0 +1,162 @@
+/**
+ @file G3D.h
+
+ This header includes all of the G3D libraries in
+ appropriate namespaces.
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2001-08-25
+ @edited 2010-01-30
+
+ Copyright 2000-2010, Morgan McGuire.
+ All rights reserved.
+*/
+
+#ifndef G3D_G3D_h
+#define G3D_G3D_h
+
+#define NOMINMAX 1
+#ifdef min
+ #undef min
+#endif
+#ifdef max
+ #undef max
+#endif
+
+#include "G3D/platform.h"
+#include "G3D/units.h"
+#include "G3D/ParseError.h"
+#include "G3D/Random.h"
+#include "G3D/Array.h"
+#include "G3D/SmallArray.h"
+#include "G3D/Queue.h"
+#include "G3D/Crypto.h"
+#include "G3D/format.h"
+#include "G3D/Vector2.h"
+#include "G3D/Vector3.h"
+#include "G3D/Vector4.h"
+#include "G3D/Color1.h"
+#include "G3D/Color3.h"
+#include "G3D/Color4.h"
+#include "G3D/Matrix2.h"
+#include "G3D/Matrix3.h"
+#include "G3D/Matrix4.h"
+#include "G3D/CoordinateFrame.h"
+#include "G3D/PhysicsFrame.h"
+#include "G3D/Plane.h"
+#include "G3D/Line.h"
+#include "G3D/Ray.h"
+#include "G3D/Sphere.h"
+#include "G3D/Box.h"
+#include "G3D/Box2D.h"
+#include "G3D/AABox.h"
+#include "G3D/WrapMode.h"
+#include "G3D/Cone.h"
+#include "G3D/Quat.h"
+#include "G3D/stringutils.h"
+#include "G3D/prompt.h"
+#include "G3D/Table.h"
+#include "G3D/Set.h"
+#include "G3D/GUniqueID.h"
+#include "G3D/BinaryFormat.h"
+#include "G3D/BinaryInput.h"
+#include "G3D/BinaryOutput.h"
+#include "G3D/debug.h"
+#include "G3D/g3dfnmatch.h"
+#include "G3D/G3DGameUnits.h"
+#include "G3D/g3dmath.h"
+#include "G3D/uint128.h"
+#include "G3D/fileutils.h"
+#include "G3D/ReferenceCount.h"
+#include "G3D/Welder.h"
+#include "G3D/GMutex.h"
+#include "G3D/PrecomputedRandom.h"
+#include "G3D/MemoryManager.h"
+#include "G3D/AreaMemoryManager.h"
+#include "G3D/BumpMapPreprocess.h"
+
+template struct HashTrait< G3D::ReferenceCountedPointer > {
+ static size_t hashCode(G3D::ReferenceCountedPointer key) { return reinterpret_cast( key.pointer() ); }
+};
+
+#include "G3D/GImage.h"
+#include "G3D/CollisionDetection.h"
+#include "G3D/Intersect.h"
+#include "G3D/Log.h"
+#include "G3D/serialize.h"
+#include "G3D/TextInput.h"
+#include "G3D/NetAddress.h"
+#include "G3D/NetworkDevice.h"
+#include "G3D/System.h"
+#include "G3D/splinefunc.h"
+#include "G3D/Spline.h"
+#include "G3D/UprightFrame.h"
+#include "G3D/LineSegment.h"
+#include "G3D/Capsule.h"
+#include "G3D/Cylinder.h"
+#include "G3D/Triangle.h"
+#include "G3D/Color3uint8.h"
+#include "G3D/Color4uint8.h"
+#include "G3D/Vector2int16.h"
+#include "G3D/Vector3int16.h"
+#include "G3D/Vector3int32.h"
+#include "G3D/Vector4int8.h"
+#include "G3D/ConvexPolyhedron.h"
+#include "G3D/MeshAlg.h"
+#include "G3D/vectorMath.h"
+#include "G3D/Rect2D.h"
+#include "G3D/GCamera.h"
+#include "G3D/GLight.h"
+#include "G3D/KDTree.h"
+#include "G3D/PointKDTree.h"
+#include "G3D/TextOutput.h"
+#include "G3D/MeshBuilder.h"
+#include "G3D/Stopwatch.h"
+#include "G3D/AtomicInt32.h"
+#include "G3D/GThread.h"
+#include "G3D/ThreadSet.h"
+#include "G3D/RegistryUtil.h"
+#include "G3D/Any.h"
+#include "G3D/PointHashGrid.h"
+#include "G3D/Map2D.h"
+#include "G3D/Image1.h"
+#include "G3D/Image1uint8.h"
+#include "G3D/Image3.h"
+#include "G3D/Image3uint8.h"
+#include "G3D/Image4.h"
+#include "G3D/Image4uint8.h"
+#include "G3D/filter.h"
+#include "G3D/WeakCache.h"
+#include "G3D/Pointer.h"
+#include "G3D/Matrix.h"
+#include "G3D/ImageFormat.h"
+
+#ifdef _MSC_VER
+# pragma comment(lib, "zlib")
+# pragma comment(lib, "ws2_32")
+# pragma comment(lib, "winmm")
+# pragma comment(lib, "imagehlp")
+# pragma comment(lib, "gdi32")
+# pragma comment(lib, "user32")
+# pragma comment(lib, "kernel32")
+# pragma comment(lib, "version")
+# pragma comment(lib, "advapi32")
+# pragma comment(lib, "png")
+# pragma comment(lib, "jpeg")
+# pragma comment(lib, "zip")
+# ifdef _DEBUG
+ // Don't link against G3D when building G3D itself.
+# ifndef G3D_BUILDING_LIBRARY_DLL
+# pragma comment(lib, "G3Dd.lib")
+# endif
+# else
+ // Don't link against G3D when building G3D itself.
+# ifndef G3D_BUILDING_LIBRARY_DLL
+# pragma comment(lib, "G3D.lib")
+# endif
+# endif
+#endif
+
+#endif
+
diff --git a/dep/include/g3dlite/G3D/G3DAll.h b/dep/include/g3dlite/G3D/G3DAll.h
new file mode 100644
index 000000000..1176fe742
--- /dev/null
+++ b/dep/include/g3dlite/G3D/G3DAll.h
@@ -0,0 +1,26 @@
+/**
+ @file G3DAll.h
+
+ Includes all G3D and GLG3D files and uses the G3D namespace.
+
+ This requires OpenGL and SDL headers. If you don't want all of this,
+ \#include separately.
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2002-01-01
+ @edited 2006-08-13
+
+ Copyright 2000-2006, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_G3DALL_H
+#define G3D_G3DALL_H
+
+#include "G3D/G3D.h"
+#include "GLG3D/GLG3D.h"
+
+using namespace G3D;
+
+#endif
diff --git a/dep/include/g3dlite/G3D/G3DGameUnits.h b/dep/include/g3dlite/G3D/G3DGameUnits.h
new file mode 100644
index 000000000..e2bc2c811
--- /dev/null
+++ b/dep/include/g3dlite/G3D/G3DGameUnits.h
@@ -0,0 +1,42 @@
+/**
+ @file G3DGameUnits.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @created 2002-10-05
+ @edited 2006-11-10
+ */
+
+#ifndef G3D_GAMEUNITS_H
+#define G3D_GAMEUNITS_H
+
+#include "G3D/platform.h"
+
+namespace G3D {
+/**
+ Time, in seconds.
+ */
+typedef double GameTime;
+typedef double SimTime;
+
+/**
+ Actual wall clock time in seconds.
+ */
+typedef double RealTime;
+
+enum AMPM {AM, PM};
+
+/** \deprecated */
+enum {SECOND=1, MINUTE=60, HOUR = 60*60, DAY=24*60*60, SUNRISE=24*60*60/4, SUNSET=24*60*60*3/4, MIDNIGHT=0, METER=1, KILOMETER=1000};
+
+/**
+ Converts a 12 hour clock time into the number of seconds since
+ midnight. Note that 12:00 PM is noon and 12:00 AM is midnight.
+
+ Example: toSeconds(10, 00, AM)
+ */
+SimTime toSeconds(int hour, int minute, double seconds, AMPM ap);
+SimTime toSeconds(int hour, int minute, AMPM ap);
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/GCamera.h b/dep/include/g3dlite/G3D/GCamera.h
index 3205f3904..018fbc85d 100644
--- a/dep/include/g3dlite/G3D/GCamera.h
+++ b/dep/include/g3dlite/G3D/GCamera.h
@@ -1,58 +1,87 @@
/**
@file GCamera.h
- @maintainer Morgan McGuire, matrix@graphics3d.com
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
- @created 2001-06-02
- @edited 2006-02-11
+ @created 2005-07-20
+ @edited 2009-04-20
*/
-#ifndef G3D_GCAMERA_H
-#define G3D_GCAMERA_H
+#ifndef G3D_GCamera_H
+#define G3D_GCamera_H
#include "G3D/platform.h"
#include "G3D/CoordinateFrame.h"
#include "G3D/Vector3.h"
#include "G3D/Plane.h"
+#include "G3D/debugAssert.h"
namespace G3D {
+class Matrix4;
+class Rect2D;
+class Any;
+
/**
- There is a viewport of width x height size in world space that corresponds to
- a screenWidth x screenHeight pixel grid on a
- renderDevice->getWidth() x renderDevice->getHeight()
- window.
+ Abstraction of a pinhole camera.
+
+ The area a camera sees is called a frustum. It is bounded by the
+ near plane, the far plane, and the sides of the view frame projected
+ into the scene. It has the shape of a pyramid with the top cut off.
+
+ Cameras can project points from 3D to 2D. The "unit" projection
+ matches OpenGL. It maps the entire view frustum to a cube of unit
+ radius (i.e., edges of length 2) centered at the origin. The
+ non-unit projection then maps that cube to the specified pixel
+ viewport in X and Y and the range [0, 1] in Z. The projection is
+ reversable as long as the projected Z value is known.
All viewport arguments are the pixel bounds of the viewport-- e.g.,
- RenderDevice::getViewport().
+ RenderDevice::viewport().
*/
class GCamera {
-private:
-
- /**
- Vertical field of view (in radians)
- */
- float fieldOfView;
-
- /**
- The image plane depth corresponding to a vertical field of
- view, where the film size is 1x1.
- */
- float imagePlaneDepth;
-
- /**
- Clipping plane, *not* imaging plane. Positive numbers.
- */
- float nearPlane;
-
- /**
- Positive
- */
- float farPlane;
-
- CoordinateFrame cframe;
public:
+ /**
+ Stores the direction of the field of view
+ */
+ enum FOVDirection {HORIZONTAL, VERTICAL};
+
+private:
+
+ /** Full field of view (in radians) */
+ float m_fieldOfView;
+
+ /** Clipping plane, *not* imaging plane. Negative numbers. */
+ float m_nearPlaneZ;
+
+ /** Negative */
+ float m_farPlaneZ;
+
+ /** Stores the camera's location and orientation */
+ CoordinateFrame m_cframe;
+
+ /** Horizontal or Vertical */
+ FOVDirection m_direction;
+
+public:
+
+ /** Must be of the format produced by the Any cast, e.g.,
+
+
+ GCamera {
+ coordinateFrame = CFrame::fromXYZYPRDegrees(-13.3f, 8.0f, -1.9f, 246.6f, -3),
+ nearPlaneZ = -0.5,
+ farPlaneZ = -50,
+ fovDirection = "HORIZONTAL",
+ fovAngleDegrees = 90
+ }
+
+ Missing fields are filled from the default GCamera constructor.
+ */
+ GCamera(const Any& any);
+
+ operator Any() const;
class Frustum {
public:
@@ -77,53 +106,97 @@ public:
Array faceArray;
};
- GCamera();
+ GCamera();
+
+ GCamera(const Matrix4& proj, const CFrame& frame);
virtual ~GCamera();
+ /** Returns the current coordinate frame */
+ const CoordinateFrame& coordinateFrame() const {
+ return m_cframe;
+ }
- CoordinateFrame getCoordinateFrame() const;
- void getCoordinateFrame(CoordinateFrame& c) const;
- void setCoordinateFrame(const CoordinateFrame& c);
+ /** Sets c to the camera's coordinate frame */
+ void getCoordinateFrame(CoordinateFrame& c) const;
+
+ /** Sets a new coordinate frame for the camera */
+ void setCoordinateFrame(const CoordinateFrame& c);
- /**
- Sets the horizontal field of view, in radians. The
- initial angle is toRadians(55).
-
- - toRadians(50) - Telephoto
-
- toRadians(110) - Normal
-
- toRadians(140) - Wide angle
-
- */
- void setFieldOfView(float angle);
+ /** Sets \a P equal to the camera's projection matrix. This is the
+ matrix that maps points to the homogeneous clip cube that
+ varies from -1 to 1 on all axes. The projection matrix does
+ not include the camera transform.
- /**
- Sets the field of view based on a desired image plane depth
- (s') and film dimensions in world space. Depth must be positive. Width,
- depth, and height are measured in the same units (meters are
- recommended). The field of view will span the diagonal to the
- image. Note: to simulate a 35mm GCamera, set width =
- 0.36 mm and height = 0.24 mm. The width and height used are
- generally not the pixel dimensions of the image.
- */
- void setImagePlaneDepth(
- float depth,
- const class Rect2D& viewport);
+ This is the matrix that a RenderDevice (or OpenGL) uses as the projection matrix.
+ @sa RenderDevice::setProjectionAndCameraMatrix, RenderDevice::setProjectionMatrix, Matrix4::perspectiveProjection
+ */
+ void getProjectUnitMatrix(const Rect2D& viewport, Matrix4& P) const;
- inline double getFieldOfView() const {
- return fieldOfView;
- }
+ /** Sets \a P equal to the matrix that transforms points to pixel
+ coordinates on the given viewport. A point correspoinding to
+ the top-left corner of the viewport in camera space will
+ transform to viewport.x0y0() and the bottom-right to viewport.x1y1(). */
+ void getProjectPixelMatrix(const Rect2D& viewport, Matrix4& P) const;
+
+ /** Converts projected points from OpenGL standards
+ (-1, 1) to normal 3D coordinate standards (0, 1)
+
+ \deprecated
+ */ // TODO: Remove
+ Vector3 convertFromUnitToNormal(const Vector3& in, const Rect2D& viewport) const;
+
+ /**
+ Sets the field of view, in radians. The
+ initial angle is toRadians(55). Must specify
+ the direction of the angle.
+
+ This is the full angle, i.e., from the left side of the
+ viewport to the right side.
+ */
+ void setFieldOfView(float angle, FOVDirection direction);
+
+ /** Returns the current full field of view angle (from the left side of the
+ viewport to the right side) and direction */
+ inline void getFieldOfView(float& angle, FOVDirection& direction) const {
+ angle = m_fieldOfView;
+ direction = m_direction;
+ }
/**
Projects a world space point onto a width x height screen. The
returned coordinate uses pixmap addressing: x = right and y =
- down. The resulting z value is rhw.
+ down. The resulting z value is 0 at the near plane, 1 at the far plane,
+ and is a linear compression of unit cube projection.
If the point is behind the camera, Vector3::inf() is returned.
*/
- G3D::Vector3 project(
- const G3D::Vector3& point,
- const class Rect2D& viewport) const;
+ Vector3 project(const G3D::Vector3& point,
+ const class Rect2D& viewport) const;
+
+ /**
+ Projects a world space point onto a unit cube. The resulting
+ x,y,z values range between -1 and 1, where z is -1
+ at the near plane and 1 at the far plane and varies hyperbolically in between.
+
+ If the point is behind the camera, Vector3::inf() is returned.
+ */
+ Vector3 projectUnit(const G3D::Vector3& point,
+ const class Rect2D& viewport) const;
+
+ /**
+ Gives the world-space coordinates of screen space point v, where
+ v.x is in pixels from the left, v.y is in pixels from
+ the top, and v.z is on the range 0 (near plane) to 1 (far plane).
+ */
+ Vector3 unproject(const Vector3& v, const Rect2D& viewport) const;
+
+ /**
+ Gives the world-space coordinates of unit cube point v, where
+ v varies from -1 to 1 on all axes. The unproject first
+ transforms the point into a pixel location for the viewport, then calls unproject
+ */
+ Vector3 unprojectUnit(const Vector3& v, const Rect2D& viewport) const;
/**
Returns the pixel area covered by a shape of the given
@@ -134,24 +207,29 @@ public:
/**
Returns the world space 3D viewport corners. These
are at the near clipping plane. The corners are constructed
- from the nearPlaneZ, getViewportWidth, and getViewportHeight.
+ from the nearPlaneZ, viewportWidth, and viewportHeight.
"left" and "right" are from the GCamera's perspective.
*/
- void get3DViewportCorners(
- const class Rect2D& viewport,
- Vector3& outUR,
- Vector3& outUL,
- Vector3& outLL,
- Vector3& outLR) const;
+ void getNearViewportCorners(const class Rect2D& viewport,
+ Vector3& outUR, Vector3& outUL,
+ Vector3& outLL, Vector3& outLR) const;
/**
- Returns the image plane depth, s', given the current field
- of view for film of dimensions width x height. See
- setImagePlaneDepth for a discussion of worldspace values width and height.
- */
- float getImagePlaneDepth(
- const class Rect2D& viewport) const;
+ Returns the world space 3D viewport corners. These
+ are at the Far clipping plane. The corners are constructed
+ from the nearPlaneZ, farPlaneZ, viewportWidth, and viewportHeight.
+ "left" and "right" are from the GCamera's perspective.
+ */
+ void getFarViewportCorners(const class Rect2D& viewport,
+ Vector3& outUR, Vector3& outUL,
+ Vector3& outLL, Vector3& outLR) const;
+ /**
+ Returns the image plane depth, assumes imagePlane
+ is the same as the near clipping plane.
+ returns a positive number.
+ */
+ float imagePlaneDepth() const;
/**
Returns the world space ray passing through the center of pixel
@@ -159,91 +237,99 @@ public:
the 3D object space axes: (0,0) is the upper left corner of the screen.
They are in viewport coordinates, not screen coordinates.
+ The ray origin is at the origin. To start it at the image plane,
+ move it forward by imagePlaneDepth/ray.direction.z
Integer (x, y) values correspond to
the upper left corners of pixels. If you want to cast rays
through pixel centers, add 0.5 to x and y.
- */
+ */
Ray worldRay(
float x,
float y,
const class Rect2D& viewport) const;
-
/**
Returns a negative z-value.
*/
- inline float getNearPlaneZ() const {
- return -nearPlane;
+ inline float nearPlaneZ() const {
+ return m_nearPlaneZ;
}
/**
Returns a negative z-value.
*/
- inline float getFarPlaneZ() const {
- return -farPlane;
+ inline float farPlaneZ() const {
+ return m_farPlaneZ;
}
- inline void setFarPlaneZ(float z) {
- debugAssert(z < 0);
- farPlane = -z;
- }
-
- inline void setNearPlaneZ(float z) {
- debugAssert(z < 0);
- nearPlane = -z;
- }
+ /**
+ Sets a new value for the far clipping plane
+ Expects a negative value
+ */
+ inline void setFarPlaneZ(float z) {
+ debugAssert(z < 0);
+ m_farPlaneZ = z;
+ }
+
+ /**
+ Sets a new value for the near clipping plane
+ Expects a negative value
+ */
+ inline void setNearPlaneZ(float z) {
+ debugAssert(z < 0);
+ m_nearPlaneZ = z;
+ }
/**
- Returns the GCamera space width of the viewport.
+ Returns the camera space width of the viewport at the near plane.
*/
- float getViewportWidth(
- const class Rect2D& viewport) const;
+ float viewportWidth(const class Rect2D& viewport) const;
/**
- Returns the GCamera space height of the viewport.
- */
- float getViewportHeight(
- const class Rect2D& viewport) const;
-
- /**
- Read back a GCamera space z-value at pixel (x, y) from the depth buffer.
- double getZValue(
- double x,
- double y,
- const class Rect2D& viewport,
- double polygonOffset = 0) const;
+ Returns the camera space height of the viewport at the near plane.
*/
+ float viewportHeight(const class Rect2D& viewport) const;
void setPosition(const Vector3& t);
+ /** Rotate the camera in place to look at the target. Does not
+ persistently look at that location when the camera moves;
+ i.e., if you move the camera and still want it to look at the
+ old target, you must call lookAt again after moving the
+ camera.)*/
void lookAt(const Vector3& position, const Vector3& up = Vector3::unitY());
- /**
- Returns the clipping planes of the frustum, in world space.
- The planes have normals facing into the view frustum.
-
- The plane order is guaranteed to be:
- Near, Right, Left, Top, Bottom, [Far]
-
- If the far plane is at infinity, the resulting array will have
- 5 planes, otherwise there will be 6.
-
- The viewport is used only to determine the aspect ratio of the screen; the
- absolute dimensions and xy values don't matter.
+ /**
+ Returns the clipping planes of the frustum, in world space.
+ The planes have normals facing into the view frustum.
+
+ The plane order is guaranteed to be:
+ Near, Right, Left, Top, Bottom, [Far]
+
+ If the far plane is at infinity, the resulting array will have
+ 5 planes, otherwise there will be 6.
+
+ The viewport is used only to determine the aspect ratio of the screen; the
+ absolute dimensions and xy values don't matter.
*/
- void getClipPlanes(
- const Rect2D& viewport,
- Array& outClip) const;
+ void getClipPlanes
+ (
+ const Rect2D& viewport,
+ Array& outClip) const;
- /**
- Returns the world space view frustum, which is a truncated pyramid describing
- the volume of space seen by this camera.
+ /**
+ Returns the world space view frustum, which is a truncated pyramid describing
+ the volume of space seen by this camera.
*/
- void getFrustum(const Rect2D& viewport, GCamera::Frustum& f) const;
-
- GCamera::Frustum frustum(const Rect2D& viewport) const;
+ void frustum(const Rect2D& viewport, GCamera::Frustum& f) const;
+ GCamera::Frustum frustum(const Rect2D& viewport) const;
+
+ /** Read and Write camera parameters */
+ void serialize(class BinaryOutput& bo) const;
+ void deserialize(class BinaryInput& bi);
+
};
} // namespace G3D
diff --git a/dep/include/g3dlite/G3D/GImage.h b/dep/include/g3dlite/G3D/GImage.h
new file mode 100644
index 000000000..8ae11134f
--- /dev/null
+++ b/dep/include/g3dlite/G3D/GImage.h
@@ -0,0 +1,607 @@
+/**
+ \file GImage.h
+
+ See G3D::GImage for details.
+
+ @cite JPEG compress/decompressor is the IJG library, used in accordance with their license.
+ @cite JPG code by John Chisholm, using the IJG Library
+ @cite TGA code by Morgan McGuire
+ @cite BMP code by John Chisholm, based on code by Edward "CGameProgrammer" Resnick mailto:cgp@gdnmail.net at ftp://ftp.flipcode.com/cotd/LoadPicture.txt
+ @cite PCX format described in the ZSOFT PCX manual http://www.nist.fss.ru/hr/doc/spec/pcx.htm#2
+ @cite PNG compress/decompressor is the libpng library, used in accordance with their license.
+ @cite PPM code by Morgan McGuire based on http://netpbm.sourceforge.net/doc/ppm.html
+
+ \maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ \created 2002-05-27
+ \edited 2010-01-04
+
+ Copyright 2000-2010, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_GImage_h
+#define G3D_GImage_h
+
+#include "G3D/platform.h"
+#include
+#include "G3D/Array.h"
+#include "G3D/g3dmath.h"
+#include "G3D/stringutils.h"
+#include "G3D/Color1uint8.h"
+#include "G3D/Color3uint8.h"
+#include "G3D/Color4uint8.h"
+#include "G3D/MemoryManager.h"
+#include "G3D/BumpMapPreprocess.h"
+
+namespace G3D {
+class BinaryInput;
+class BinaryOutput;
+
+
+/**
+ Interface to image compression & file formats.
+
+ Supported formats (decode and encode): Color JPEG, PNG,
+ (Uncompressed)TGA 24, (Uncompressed)TGA 32, BMP 1, BMP 4, BMP 8, BMP
+ 24, PPM (P6), and PPM ASCII (P1, P2, P3), which includes PPM, PGM,
+ and PBM. 8-bit paletted PCX, 24-bit PCX, and ICO are supported for
+ decoding only.
+
+ Sample usage:
+
+ \verbatim
+ // Loading from disk:
+ G3D::GImage im1("test.jpg");
+
+ // Loading from memory:
+ G3D::GImage im2(data, length);
+
+ // im.pixel is a pointer to RGB color data. If you want
+ // an alpha channel, call RGBtoRGBA or RGBtoARGB for
+ // conversion.
+
+ // Saving to memory:
+ G3D::GImage im3(width, height);
+ // (Set the pixels of im3...)
+ uint8* data2;
+ int len2;
+ im3.encode(G3D::GImage::JPEG, data2, len2);
+
+ // Saving to disk
+ im3.save("out.jpg");
+ \endverbatim
+
+ The free Image Magick Magick Wand API
+ (http://www.imagemagick.org/www/api/magick_wand.html) provides a more powerful
+ API for image manipulation and wider set of image load/save formats. It is
+ recommended over GImage (we don't include it directly in G3D because their license
+ is more restrictive than the BSD one).
+
+ */
+class GImage {
+private:
+
+ /** Used exclusively for allocating m_byte; this may be an
+ implementation that allocates directly on a GPU.*/
+ MemoryManager::Ref m_memMan;
+ uint8* m_byte;
+
+ int m_channels;
+ int m_width;
+ int m_height;
+
+public:
+
+ class Error {
+ public:
+ Error(
+ const std::string& reason,
+ const std::string& filename = "") :
+ reason(reason), filename(filename) {}
+
+ std::string reason;
+ std::string filename;
+ };
+
+ /** PGM, PPM, and PBM all come in two versions and are classified as PPM_* files */
+ enum Format {JPEG, BMP, TGA, PCX, ICO, PNG,
+ PPM_BINARY, PGM_BINARY = PPM_BINARY,
+ PPM_ASCII, PGM_ASCII = PPM_ASCII,
+ AUTODETECT, UNKNOWN};
+
+
+ /**
+ The number of channels; either 3 (RGB) or 4 (RGBA)
+ */
+ inline int channels() const {
+ return m_channels;
+ }
+
+ inline int width() const {
+ return m_width;
+ }
+
+ inline int height() const {
+ return m_height;
+ }
+
+ inline const uint8* byte() const {
+ return m_byte;
+ }
+
+ /** Returns a pointer to the underlying data, which is stored
+ in row-major order without row padding.
+ e.g., uint8* ptr = image.rawData();
+ */
+ template
+ inline const Type* rawData() const {
+ return (Type*)m_byte;
+ }
+
+ /** \copybrief GImage::rawData() const */
+ template
+ inline Type* rawData() {
+ return (Type*)m_byte;
+ }
+
+ inline const Color1uint8* pixel1() const {
+ debugAssertM(m_channels == 1, format("Tried to call GImage::pixel1 on an image with %d channels", m_channels));
+ return (Color1uint8*)m_byte;
+ }
+
+ inline Color1uint8* pixel1() {
+ debugAssertM(m_channels == 1, format("Tried to call GImage::pixel1 on an image with %d channels", m_channels));
+ return (Color1uint8*)m_byte;
+ }
+
+ /** Returns a pointer to the upper left pixel
+ as Color4uint8.
+ */
+ inline const Color4uint8* pixel4() const {
+ debugAssertM(m_channels == 4, format("Tried to call GImage::pixel4 on an image with %d channels", m_channels));
+ return (Color4uint8*)m_byte;
+ }
+
+ inline Color4uint8* pixel4() {
+ debugAssert(m_channels == 4);
+ return (Color4uint8*)m_byte;
+ }
+
+ /** Returns a pointer to the upper left pixel
+ as Color3uint8.
+ */
+ inline const Color3uint8* pixel3() const {
+ debugAssertM(m_channels == 3, format("Tried to call GImage::pixel3 on an image with %d channels", m_channels));
+ return (Color3uint8*)m_byte;
+ }
+
+ inline Color3uint8* pixel3() {
+ debugAssert(m_channels == 3);
+ return (Color3uint8*)m_byte;
+ }
+
+ /** Returns the pixel at (x, y), where (0,0) is the upper left. */
+ inline const Color1uint8& pixel1(int x, int y) const {
+ debugAssert(x >= 0 && x < m_width);
+ debugAssert(y >= 0 && y < m_height);
+ return pixel1()[x + y * m_width];
+ }
+
+ /** Returns the pixel at (x, y), where (0,0) is the upper left. */
+ inline Color1uint8& pixel1(int x, int y) {
+ debugAssert(x >= 0 && x < m_width);
+ debugAssert(y >= 0 && y < m_height);
+ return pixel1()[x + y * m_width];
+ }
+
+ /** Returns the pixel at (x, y), where (0,0) is the upper left. */
+ inline const Color3uint8& pixel3(int x, int y) const {
+ debugAssert(x >= 0 && x < m_width);
+ debugAssert(y >= 0 && y < m_height);
+ return pixel3()[x + y * m_width];
+ }
+
+ inline Color3uint8& pixel3(int x, int y) {
+ debugAssert(x >= 0 && x < m_width);
+ debugAssert(y >= 0 && y < m_height);
+ return pixel3()[x + y * m_width];
+ }
+
+ /** Returns the pixel at (x, y), where (0,0) is the upper left. */
+ inline const Color4uint8& pixel4(int x, int y) const {
+ debugAssert(x >= 0 && x < m_width);
+ debugAssert(y >= 0 && y < m_height);
+ return pixel4()[x + y * m_width];
+ }
+
+ inline Color4uint8& pixel4(int x, int y) {
+ debugAssert(x >= 0 && x < m_width);
+ debugAssert(y >= 0 && y < m_height);
+ return pixel4()[x + y * m_width];
+ }
+
+ inline uint8* byte() {
+ return m_byte;
+ }
+
+private:
+
+ void encodeBMP(
+ BinaryOutput& out) const;
+
+ /**
+ The TGA file will be either 24- or 32-bit depending
+ on the number of channels.
+ */
+ void encodeTGA(
+ BinaryOutput& out) const;
+
+ /**
+ Converts this image into a JPEG
+ */
+ void encodeJPEG(
+ BinaryOutput& out) const;
+
+ /**
+ Converts this image into a JPEG
+ */
+ void encodePNG(
+ BinaryOutput& out) const;
+
+ void encodePPM(
+ BinaryOutput& out) const;
+
+ void encodePPMASCII(
+ BinaryOutput& out) const;
+
+ void decodeTGA(
+ BinaryInput& input);
+
+ void decodeBMP(
+ BinaryInput& input);
+
+ void decodeJPEG(
+ BinaryInput& input);
+
+ void decodePCX(
+ BinaryInput& input);
+
+ void decodeICO(
+ BinaryInput& input);
+
+ void decodePNG(
+ BinaryInput& input);
+
+ void decodePPM(
+ BinaryInput& input);
+
+ void decodePPMASCII(
+ BinaryInput& input);
+
+ /**
+ Given [maybe] a filename, memory buffer, and [maybe] a format,
+ returns the most likely format of this file.
+ */
+ static Format resolveFormat(
+ const std::string& filename,
+ const uint8* data,
+ int dataLen,
+ Format maybeFormat);
+
+ void _copy(
+ const GImage& other);
+
+public:
+
+ /** Predicts the image file format of \a filename */
+ static Format resolveFormat(const std::string& filename);
+
+ void flipHorizontal();
+ void flipVertical();
+ void rotate90CW(int numTimes = 1);
+
+ /**
+ Create an empty image of the given size.
+ \sa load()
+ */
+ GImage(
+ int width = 0,
+ int height = 0,
+ int channels = 3,
+ const MemoryManager::Ref& m = MemoryManager::create());
+
+ /**
+ Load an encoded image from disk and decode it.
+ Throws GImage::Error if something goes wrong.
+ */
+ GImage(
+ const std::string& filename,
+ Format format = AUTODETECT,
+ const MemoryManager::Ref& m = MemoryManager::create());
+
+ /**
+ Decodes an image stored in a buffer.
+ */
+ GImage(
+ const unsigned char*data,
+ int length,
+ Format format = AUTODETECT,
+ const MemoryManager::Ref& m = MemoryManager::create());
+
+ GImage(
+ const GImage& other,
+ const MemoryManager::Ref& m = MemoryManager::create());
+
+ GImage& operator=(const GImage& other);
+
+ /**
+ Returns a new GImage that has 4 channels. RGB is
+ taken from this GImage and the alpha from the red
+ channel of the supplied image. The new GImage is passed
+ as a reference parameter for speed.
+ */
+ void insertRedAsAlpha(const GImage& alpha, GImage& output) const;
+
+ /**
+ Returns a new GImage with 3 channels, removing
+ the alpha channel if there is one. The new GImage
+ is passed as a reference parameter for speed.
+ */
+ void stripAlpha(GImage& output) const;
+
+ /**
+ Loads an image from disk (clearing the old one first),
+ using the existing memory manager.
+ */
+ void load(
+ const std::string& filename,
+ Format format = AUTODETECT);
+
+ /**
+ Frees memory and resets to a 0x0 image.
+ */
+ void clear();
+
+ /**
+ Deallocates the pixels.
+ */
+ virtual ~GImage();
+
+ /**
+ Resizes the internal buffer to (\a width x \a height) with the
+ number of \a channels specified.
+
+ \param zero If true, all data is set to 0 (black).
+ */
+ void resize(int width, int height, int channels, bool zero = true);
+
+ /**
+ Copies src sub-image data into dest at a certain offset.
+ The dest variable must already contain an image that is large
+ enough to contain the src sub-image at the specified offset.
+ Returns true on success and false if the src sub-image cannot
+ completely fit within dest at the specified offset. Both
+ src and dest must have the same number of channels.
+ */
+ static bool pasteSubImage(
+ GImage& dest,
+ const GImage& src,
+ int destX,
+ int destY,
+ int srcX,
+ int srcY,
+ int srcWidth,
+ int srcHeight);
+
+ /**
+ creates dest from src sub-image data.
+ Returns true on success and false if the src sub-image
+ is not within src.
+ */
+ static bool copySubImage(GImage & dest, const GImage & src,
+ int srcX, int srcY, int srcWidth, int srcHeight);
+
+ void convertToRGBA();
+
+ void convertToRGB();
+
+ /** Averages color channels if they exist */
+ void convertToL8();
+
+ /**
+ Returns true if format is supported. Format
+ should be an extension string (e.g. "BMP").
+ */
+ static bool supportedFormat(
+ const std::string& format);
+
+ /**
+ Converts a string to an enum, returns UNKNOWN if not recognized.
+ */
+ static Format stringToFormat(
+ const std::string& format);
+
+ /**
+ Encode and save to disk.
+ */
+ void save(
+ const std::string& filename,
+ Format format = AUTODETECT) const;
+
+ /**
+ The caller must delete the returned buffer.
+ TODO: provide a memory manager
+ */
+ void encode(
+ Format format,
+ uint8*& outData,
+ int& outLength) const;
+
+ /**
+ Does not commit the BinaryOutput when done.
+ */
+ void encode(
+ Format format,
+ BinaryOutput& out) const;
+
+ /**
+ Decodes the buffer into this image.
+ @param format Must be the correct format.
+ */
+ void decode(
+ BinaryInput& input,
+ Format format);
+
+ /** Returns the size of this object in bytes */
+ int sizeInMemory() const;
+
+ /** Ok for in == out */
+ static void R8G8B8_to_Y8U8V8(int width, int height, const uint8* in, uint8* out);
+
+ /** Ok for in == out */
+ static void Y8U8V8_to_R8G8B8(int width, int height, const uint8* in, uint8* out);
+
+ /**
+ @param in RGB buffer of numPixels * 3 bytes
+ @param out Buffer of numPixels * 4 bytes
+ @param numPixels Number of RGB pixels to convert
+ */
+ static void RGBtoRGBA(
+ const uint8* in,
+ uint8* out,
+ int numPixels);
+
+ static void RGBtoARGB(
+ const uint8* in,
+ uint8* out,
+ int numPixels);
+
+ static void LtoRGB
+ (const uint8* in,
+ uint8* out,
+ int numPixels);
+
+ static void LtoRGBA
+ (const uint8* in,
+ uint8* out,
+ int numPixels);
+
+ /** Safe for in == out */
+ static void RGBtoBGR(
+ const uint8* in,
+ uint8* out,
+ int numPixels);
+
+ /**
+ Win32 32-bit HDC format.
+ */
+ static void RGBtoBGRA(
+ const uint8* in,
+ uint8* out,
+ int numPixels);
+
+ static void RGBAtoRGB(
+ const uint8* in,
+ uint8* out,
+ int numPixels);
+ /**
+ Uses the red channel of the second image as an alpha channel.
+ */
+ static void RGBxRGBtoRGBA(
+ const uint8* colorRGB,
+ const uint8* alphaRGB,
+ uint8* out,
+ int numPixels);
+
+ /**
+ Flips the image along the vertical axis.
+ Safe for in == out.
+ */
+ static void flipRGBVertical(
+ const uint8* in,
+ uint8* out,
+ int width,
+ int height);
+
+ static void flipRGBAVertical(
+ const uint8* in,
+ uint8* out,
+ int width,
+ int height);
+
+ /**
+ Given a tangent space bump map, computes a new image where the
+ RGB channels are a tangent space normal map and the alpha channel
+ is the original bump map. Assumes the input image is tileable.
+
+ In the resulting image, x = red = tangent, y = green = binormal, and z = blue = normal.
+
+ Particularly useful as part of the idiom:
+
+ GImage normal;
+ computeNormalMap(GImage(filename), normal);
+ return Texture::fromGImage(filename, normal);
+
+
+ */
+ static void computeNormalMap(
+ const class GImage& bump,
+ class GImage& normal,
+ const BumpMapPreprocess& preprocess = BumpMapPreprocess());
+
+ static void computeNormalMap
+ (int width,
+ int height,
+ int channels,
+ const uint8* src,
+ GImage& normal,
+ const BumpMapPreprocess& preprocess = BumpMapPreprocess());
+
+ /**
+ Bayer demosaicing using the filter proposed in
+
+ HIGH-QUALITY LINEAR INTERPOLATION FOR DEMOSAICING OF BAYER-PATTERNED COLOR IMAGES
+ Henrique S. Malvar, Li-wei He, and Ross Cutler
+
+ The filter wraps at the image boundaries.
+
+ Assumes in != out.
+ */
+ static void BAYER_G8B8_R8G8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out);
+ static void BAYER_G8R8_B8G8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out);
+ static void BAYER_R8G8_G8B8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out);
+ static void BAYER_B8G8_G8R8_to_R8G8B8_MHC(int w, int h, const uint8* in, uint8* _out);
+
+ /** Fast conversion; the output has 1/2 the size of the input in each direction. Assumes in != out.
+ See G3D::BAYER_G8B8_R8G8_to_R8G8B8_MHC for a much better result. */
+ static void BAYER_G8B8_R8G8_to_Quarter_R8G8B8
+ (int inWidth,
+ int inHeight,
+ const uint8* in,
+ uint8* out);
+
+ /** Attempt to undo fast conversion of G3D::BAYER_G8B8_R8G8_to_Quarter_R8G8B8;
+ the green channel will lose data. Assumes in != out
+ The input should have size 3 * inWidth * inHeight. The output should have size
+ 2 * inWidth * 2 * inHeight.
+ */
+ static void Quarter_R8G8B8_to_BAYER_G8B8_R8G8
+ (int inWidth,
+ int inHeight,
+ const uint8* in,
+ uint8* out);
+
+ /** Overwrites every pixel with one of the two colors in a checkerboard pattern.
+ The fields used from the two colors depend on the current number of channels in @a im.
+ */
+ static void makeCheckerboard
+ (GImage& im,
+ int checkerSize = 1,
+ const Color4uint8& color1 = Color4uint8(255,255,255,255),
+ const Color4uint8& color2 = Color4uint8(0,0,0,255));
+};
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/GLight.h b/dep/include/g3dlite/G3D/GLight.h
new file mode 100644
index 000000000..3a95f1a81
--- /dev/null
+++ b/dep/include/g3dlite/G3D/GLight.h
@@ -0,0 +1,106 @@
+/**
+ @file GLight.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-11-12
+ @edited 2009-11-08
+*/
+
+#ifndef G3D_GLight_h
+#define G3D_GLight_h
+
+#include "G3D/platform.h"
+#include "G3D/Vector4.h"
+#include "G3D/Vector3.h"
+#include "G3D/Color4.h"
+
+namespace G3D {
+class Any;
+
+/**
+ A light representation that closely follows the OpenGL light format.
+ */
+class GLight {
+public:
+ /** World space position (for a directional light, w = 0 */
+ Vector4 position;
+
+ /** For a spot or directional light, this is the "right vector" that will be used when constructing
+ a reference frame(). */
+ Vector3 rightDirection;
+
+ /** Direction in which the light faces, if a spot light. This is the "look vector" of the light source. */
+ Vector3 spotDirection;
+
+ /** In degrees. 180 = no cutoff (point/dir). Values less than 90 = spot light */
+ float spotCutoff;
+
+ /** If true, G3D::SuperShader will render a cone of light large
+ enough to encompass the entire square that bounds the cutoff
+ angle. This produces a square prism instead of a cone of light
+ when used with a G3D::ShadowMap. for an unshadowed light this
+ has no effect.*/
+ bool spotSquare;
+
+ /** Constant, linear, quadratic */
+ float attenuation[3];
+
+ /** May be outside the range [0, 1] */
+ Color3 color;
+
+ /** If false, this light is ignored */
+ bool enabled;
+
+ /** If false, this light does not create specular highlights
+ (useful when using negative lights). */
+ bool specular;
+
+ /** If false, this light does not create diffuse illumination
+ (useful when rendering a specular-only pass). */
+ bool diffuse;
+
+ GLight();
+
+ /** Accepted forms:
+ - GLight::directional( vector3, color3, [bool, [bool]])
+ - GLight::spot(vector3, vector3, #, color3, [#, [#, [#, [#, [bool, [bool]]]])
+ - GLight::point(vector3, color3, [#, [#, [#, [#, [bool, [bool]]]])
+ - GLight { [all fields] }
+ */
+ GLight(const Any& any);
+
+ /** Converts the Color3 to an Any. */
+ operator Any() const;
+
+ /** @param toLight will be normalized */
+ static GLight directional(const Vector3& toLight, const Color3& color, bool specular = true, bool diffuse = true);
+
+ static GLight point(const Vector3& pos, const Color3& color, float constAtt = 1, float linAtt = 0, float quadAtt = 0.5f, bool specular = true, bool diffuse = true);
+
+ /** @param pointDirection Will be normalized. Points in the
+ direction that light propagates.
+
+ @param cutOffAngleDegrees Must be on the range [0, 90]. This
+ is the angle from the point direction to the edge of the light
+ cone. I.e., a value of 45 produces a light with a 90-degree
+ cone of view.
+ */
+ static GLight spot(const Vector3& pos, const Vector3& pointDirection, float cutOffAngleDegrees,
+ const Color3& color, float constAtt = 1, float linAtt = 0, float quadAtt = 0,
+ bool specular = true, bool diffuse = true);
+
+ /** Returns the sphere within which this light has some noticable effect. May be infinite.
+ @param cutoff The value at which the light intensity is considered negligible. */
+ class Sphere effectSphere(float cutoff = 30.0f / 255) const;
+
+ /** Computes a reference frame (e.g., for use with G3D::ShadowMap */
+ class CoordinateFrame frame() const;
+
+ bool operator==(const GLight& other) const;
+ bool operator!=(const GLight& other) const;
+};
+
+} // namespace
+#endif
+
diff --git a/dep/include/g3dlite/G3D/GMutex.h b/dep/include/g3dlite/G3D/GMutex.h
new file mode 100644
index 000000000..3469b8127
--- /dev/null
+++ b/dep/include/g3dlite/G3D/GMutex.h
@@ -0,0 +1,123 @@
+/**
+ @file GMutex.h
+
+ @created 2005-09-22
+ @edited 2009-03-25
+ */
+
+#ifndef G3D_GMutex_h
+#define G3D_GMutex_h
+
+#include "G3D/platform.h"
+#include "G3D/AtomicInt32.h"
+#include "G3D/debugAssert.h"
+#include
+
+#ifndef G3D_WIN32
+# include
+# include
+#endif
+
+
+namespace G3D {
+
+/**
+ \brief A mutual exclusion lock that busy-waits when locking.
+
+ On a machine with one (significant) thread per processor core,
+ a spinlock may be substantially faster than a mutex.
+
+ \sa G3D::GThread, G3D::GMutex, G3D::AtomicInt32
+ */
+class Spinlock {
+private:
+
+ AtomicInt32 x;
+
+public:
+
+ inline Spinlock() : x(0) {}
+
+ /** Busy waits until the lock is unlocked, then locks it
+ exclusively. Returns true if the lock succeeded on the first
+ try (indicating no contention). */
+ inline bool lock() {
+ bool first = true;
+ while (x.compareAndSet(0, 1) == 1) {
+ first = false;
+# ifdef G3D_WIN32
+ Sleep(0);
+# else
+ usleep(0);
+# endif
+ }
+ return first;
+ }
+
+ inline void unlock() {
+ x.compareAndSet(1, 0);
+ }
+
+};
+
+/**
+ \brief Mutual exclusion lock used for synchronization.
+
+ @sa G3D::GThread, G3D::AtomicInt32, G3D::Spinlock
+*/
+class GMutex {
+private:
+# ifdef G3D_WIN32
+ CRITICAL_SECTION m_handle;
+# else
+ pthread_mutex_t m_handle;
+ pthread_mutexattr_t m_attr;
+# endif
+
+ // Not implemented on purpose, don't use
+ GMutex(const GMutex &mlock);
+ GMutex &operator=(const GMutex &);
+ bool operator==(const GMutex&);
+
+public:
+ GMutex();
+ ~GMutex();
+
+ /** Locks the mutex or blocks until available. */
+ void lock();
+
+ /** Locks the mutex if it not already locked.
+ Returns true if lock successful, false otherwise. */
+ bool tryLock();
+
+ /** Unlocks the mutex. */
+ void unlock();
+};
+
+
+/**
+ Automatically locks while in scope.
+*/
+class GMutexLock {
+private:
+ GMutex* m;
+
+ // Not implemented on purpose, don't use
+ GMutexLock(const GMutexLock &mlock);
+ GMutexLock &operator=(const GMutexLock &);
+ bool operator==(const GMutexLock&);
+
+public:
+ GMutexLock(GMutex* mutex) {
+ m = mutex;
+ m->lock();
+ }
+
+ ~GMutexLock() {
+ m->unlock();
+ }
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/GThread.h b/dep/include/g3dlite/G3D/GThread.h
new file mode 100644
index 000000000..58437efc3
--- /dev/null
+++ b/dep/include/g3dlite/G3D/GThread.h
@@ -0,0 +1,121 @@
+/**
+ @file GThread.h
+
+ @created 2005-09-22
+ @edited 2007-01-31
+
+ */
+
+#ifndef G3D_GTHREAD_H
+#define G3D_GTHREAD_H
+
+#include "G3D/platform.h"
+#include "G3D/ReferenceCount.h"
+#include
+
+#ifndef G3D_WIN32
+# include
+# include
+#endif
+
+
+namespace G3D {
+
+typedef ReferenceCountedPointer GThreadRef;
+
+/**
+ Platform independent thread implementation. You can either subclass and
+ override GThread::threadMain or call the create method with a method.
+
+ Beware of reference counting and threads. If circular references exist between
+ GThread subclasses then neither class will ever be deallocated. Also,
+ dropping all pointers (and causing deallocation) of a GThread does NOT
+ stop the underlying process.
+
+ @sa G3D::GMutex, G3D::Spinlock, G3D::AtomicInt32
+*/
+class GThread : public ReferenceCountedObject {
+private:
+ // "Status" is a reserved work on FreeBSD
+ enum GStatus {STATUS_CREATED, STATUS_STARTED, STATUS_RUNNING, STATUS_COMPLETED};
+
+ // Not implemented on purpose, don't use
+ GThread(const GThread &);
+ GThread& operator=(const GThread&);
+ bool operator==(const GThread&);
+
+#ifdef G3D_WIN32
+ static DWORD WINAPI internalThreadProc(LPVOID param);
+#else
+ static void* internalThreadProc(void* param);
+#endif //G3D_WIN32
+
+ volatile GStatus m_status;
+
+ // Thread handle to hold HANDLE and pthread_t
+#ifdef G3D_WIN32
+ HANDLE m_handle;
+ HANDLE m_event;
+#else
+ pthread_t m_handle;
+#endif //G3D_WIN32
+
+ std::string m_name;
+
+protected:
+
+ /** Overriden by the thread implementor */
+ virtual void threadMain() = 0;
+
+public:
+ typedef ReferenceCountedPointer Ref;
+ enum SpawnBehavior {USE_NEW_THREAD, USE_CURRENT_THREAD};
+
+ GThread(const std::string& name);
+
+ virtual ~GThread();
+
+ /** Constructs a basic GThread without requiring a subclass.
+
+ @param proc The global or static function for the threadMain() */
+ static GThreadRef create(const std::string& name, void (*proc)(void*), void* param = NULL);
+
+ /** Starts the thread and executes threadMain(). Returns false if
+ the thread failed to start (either because it was already started
+ or because the OS refused).
+
+ @param behavior If USE_CURRENT_THREAD, rather than spawning a new thread, this routine
+ runs threadMain on the current thread.
+ */
+ bool start(SpawnBehavior behavior = USE_NEW_THREAD);
+
+ /** Terminates the thread without notifying or
+ waiting for a cancelation point. */
+ void terminate();
+
+ /**
+ Returns true if threadMain is currently executing. This will
+ only be set when the thread is actually running and might not
+ be set when start() returns. */
+ bool running() const;
+
+ /** True after start() has been called, even through the thread
+ may have already completed(), or be currently running().*/
+ bool started() const;
+
+ /** Returns true if the thread has exited. */
+ bool completed() const;
+
+ /** Waits for the thread to finish executing. */
+ void waitForCompletion();
+
+ /** Returns thread name */
+ inline const std::string& name() {
+ return m_name;
+ }
+};
+
+
+} // namespace G3D
+
+#endif //G3D_GTHREAD_H
diff --git a/dep/include/g3dlite/G3D/GUniqueID.h b/dep/include/g3dlite/G3D/GUniqueID.h
new file mode 100644
index 000000000..c8b775c2e
--- /dev/null
+++ b/dep/include/g3dlite/G3D/GUniqueID.h
@@ -0,0 +1,69 @@
+/**
+ @file GUniqueID.h
+ @author Morgan McGuire, http://graphics.cs.williams.edu
+ */
+#ifndef G3D_GUNIQUEID_H
+#define G3D_GUNIQUEID_H
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/Table.h"
+
+namespace G3D {
+
+/** Globally unique identifiers. The probability of two different
+ programs generating the same value from UniqueID::create is
+ vanishingly small.
+
+ UniqueIDs optionally contain a 10-bit application specific tag
+ that distinguishes their type.
+*/
+class GUniqueID {
+private:
+
+ uint64 id;
+
+public:
+
+ GUniqueID() : id(0) {}
+
+ bool uninitialized() const {
+ return id == 0;
+ }
+
+ uint16 tag() const {
+ return id >> 54;
+ }
+
+ operator uint64() const {
+ return id;
+ }
+
+ bool operator==(const GUniqueID& other) const {
+ return id == other.id;
+ }
+
+ bool operator!=(const GUniqueID& other) const {
+ return id != other.id;
+ }
+
+ void serialize(class BinaryOutput& b) const;
+
+ void deserialize(class BinaryInput& b);
+
+ void serialize(class TextOutput& t) const;
+
+ void deserialize(class TextInput& t);
+
+ /** Create a new ID */
+ static GUniqueID create(uint16 tag = 0);
+};
+
+} // G3D
+
+/** For Table and Set */
+template<> struct HashTrait {
+ static size_t hashCode(G3D::GUniqueID id) { return (size_t)(G3D::uint64)id; }
+};
+
+#endif
diff --git a/dep/include/g3dlite/G3D/HashTrait.h b/dep/include/g3dlite/G3D/HashTrait.h
new file mode 100644
index 000000000..ca35da486
--- /dev/null
+++ b/dep/include/g3dlite/G3D/HashTrait.h
@@ -0,0 +1,92 @@
+/**
+ @file HashTrait.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @created 2008-10-01
+ @edited 2009-11-01
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_HashTrait_h
+#define G3D_HashTrait_h
+
+#include "G3D/platform.h"
+#include "G3D/Crypto.h"
+#include "G3D/g3dmath.h"
+#include "G3D/uint128.h"
+
+/** Must be specialized for custom types.
+ @see G3D::Table for specialization requirements.
+*/
+template struct HashTrait{};
+
+template struct HashTrait {
+ static size_t hashCode(const void* k) { return reinterpret_cast(k); }
+};
+
+#if 0
+template <> struct HashTrait {
+ static size_t hashCode(int k) { return static_cast(k); }
+};
+#endif
+
+template <> struct HashTrait {
+ static size_t hashCode(G3D::int16 k) { return static_cast(k); }
+};
+
+template <> struct HashTrait {
+ static size_t hashCode(G3D::uint16 k) { return static_cast(k); }
+};
+
+//template <> struct HashTrait {
+// static size_t hashCode(int k) { return static_cast(k); }
+//};
+
+template <> struct HashTrait {
+ static size_t hashCode(G3D::int32 k) { return static_cast(k); }
+};
+
+template <> struct HashTrait {
+ static size_t hashCode(G3D::uint32 k) { return static_cast(k); }
+};
+
+#if 0
+template <> struct HashTrait {
+ static size_t hashCode(G3D::uint32 k) { return static_cast(k); }
+};
+#endif
+
+template <> struct HashTrait {
+ static size_t hashCode(G3D::int64 k) { return static_cast(k); }
+};
+
+template <> struct HashTrait {
+ static size_t hashCode(G3D::uint64 k) { return static_cast(k); }
+};
+
+template <> struct HashTrait {
+ static size_t hashCode(const std::string& k) { return static_cast(G3D::Crypto::crc32(k.c_str(), k.size())); }
+};
+
+template <> struct HashTrait {
+ // Use the FNV-1 hash (http://isthe.com/chongo/tech/comp/fnv/#FNV-1).
+ static size_t hashCode(G3D::uint128 key) {
+ static const G3D::uint128 FNV_PRIME_128(1 << 24, 0x159);
+ static const G3D::uint128 FNV_OFFSET_128(0xCF470AAC6CB293D2ULL, 0xF52F88BF32307F8FULL);
+
+ G3D::uint128 hash = FNV_OFFSET_128;
+ G3D::uint128 mask(0, 0xFF);
+ for (int i = 0; i < 16; ++i) {
+ hash *= FNV_PRIME_128;
+ hash ^= (mask & key);
+ key >>= 8;
+ }
+
+ G3D::uint64 foldedHash = hash.hi ^ hash.lo;
+ return static_cast((foldedHash >> 32) ^ (foldedHash & 0xFFFFFFFF));
+ }
+};
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Image1.h b/dep/include/g3dlite/G3D/Image1.h
new file mode 100644
index 000000000..711e83f20
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Image1.h
@@ -0,0 +1,81 @@
+/**
+ @file Image1.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2007-01-31
+ @edited 2007-01-31
+*/
+
+
+#ifndef G3D_IMAGE1_H
+#define G3D_IMAGE1_H
+
+#include "G3D/platform.h"
+#include "G3D/Map2D.h"
+#include "G3D/Color1.h"
+#include "G3D/GImage.h"
+
+namespace G3D {
+
+typedef ReferenceCountedPointer Image1Ref;
+
+/**
+ Luminance image with 32-bit floating point storage.
+
+ See also G3D::Image1uint8, G3D::GImage.
+ */
+class Image1 : public Map2D {
+public:
+
+ typedef Image1 Type;
+ typedef ReferenceCountedPointer Ref;
+ typedef Color1 Storage;
+ typedef Color1 Compute;
+
+protected:
+
+ Image1(int w, int h, WrapMode wrap);
+
+ void copyGImage(const class GImage& im);
+ void copyArray(const Color1* src, int w, int h);
+ void copyArray(const Color3* src, int w, int h);
+ void copyArray(const Color4* src, int w, int h);
+ void copyArray(const Color1uint8* src, int w, int h);
+ void copyArray(const Color3uint8* src, int w, int h);
+ void copyArray(const Color4uint8* src, int w, int h);
+
+public:
+
+ const class ImageFormat* format() const;
+
+ /** Creates an all-zero width x height image. */
+ static Ref createEmpty(int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ /** Creates a 0 x 0 image. */
+ static Ref createEmpty(WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromFile(const std::string& filename, WrapMode wrap = WrapMode::ERROR, GImage::Format fmt = GImage::AUTODETECT);
+
+ static Ref fromArray(const class Color1uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color1* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromImage1uint8(const ReferenceCountedPointer& im);
+
+ static Ref fromGImage(const class GImage& im, WrapMode wrap = WrapMode::ERROR);
+
+ /** Loads from any of the file formats supported by G3D::GImage. If there is an alpha channel on the input,
+ it is stripped. */
+ void load(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Saves in any of the formats supported by G3D::GImage. */
+ void save(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Image1uint8.h b/dep/include/g3dlite/G3D/Image1uint8.h
new file mode 100644
index 000000000..f32e022e9
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Image1uint8.h
@@ -0,0 +1,80 @@
+/**
+ @file Image1uint8.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2007-01-31
+ @edited 2007-01-31
+*/
+
+#ifndef G3D_IMAGE1UINT8_H
+#define G3D_IMAGE1UINT8_H
+
+#include "G3D/platform.h"
+#include "G3D/Map2D.h"
+#include "G3D/Color1uint8.h"
+#include "G3D/Color1.h"
+#include "G3D/GImage.h"
+
+namespace G3D {
+
+typedef ReferenceCountedPointer Image1uint8Ref;
+
+/**
+ Compact storage for luminance 8-bit images.
+
+ See also G3D::Image3, G3D::GImage
+ */
+class Image1uint8 : public Map2D {
+public:
+
+ typedef Image1uint8 Type;
+ typedef Image1uint8Ref Ref;
+
+protected:
+
+ Image1uint8(int w, int h, WrapMode wrap);
+
+ void copyGImage(const class GImage& im);
+ void copyArray(const Color1* src, int w, int h);
+ void copyArray(const Color3* src, int w, int h);
+ void copyArray(const Color4* src, int w, int h);
+ void copyArray(const Color1uint8* src, int w, int h);
+ void copyArray(const Color3uint8* src, int w, int h);
+ void copyArray(const Color4uint8* src, int w, int h);
+
+public:
+
+ const class ImageFormat* format() const;
+
+ /** Creates an all-zero width x height image. */
+ static Ref createEmpty(int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ /** Creates a 0 x 0 image. */
+ static Ref createEmpty(WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromFile(const std::string& filename, WrapMode wrap = WrapMode::ERROR, GImage::Format fmt = GImage::AUTODETECT);
+
+ static Ref fromGImage(const class GImage& im, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromArray(const class Color1uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color1* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromImage1(const ReferenceCountedPointer& im);
+ static Ref fromImage3uint8(const ReferenceCountedPointer& im);
+
+ /** Loads from any of the file formats supported by G3D::GImage. If there is an alpha channel on the input,
+ it is stripped. */
+ void load(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Saves in any of the formats supported by G3D::GImage. */
+ void save(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Image3.h b/dep/include/g3dlite/G3D/Image3.h
new file mode 100644
index 000000000..13cb8fa7f
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Image3.h
@@ -0,0 +1,81 @@
+/**
+ @file Image3.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2007-01-31
+ @edited 2007-01-31
+*/
+
+
+#ifndef G3D_IMAGE3_H
+#define G3D_IMAGE3_H
+
+#include "G3D/platform.h"
+#include "G3D/Map2D.h"
+#include "G3D/Color3.h"
+#include "G3D/GImage.h"
+
+namespace G3D {
+
+typedef ReferenceCountedPointer Image3Ref;
+
+/**
+ RGB image with 32-bit floating point storage for each channel.
+
+ See also G3D::Image3uint8, G3D::GImage.
+ */
+class Image3 : public Map2D {
+public:
+
+ typedef Image3 Type;
+ typedef ReferenceCountedPointer Ref;
+ typedef Color3 Storage;
+ typedef Color3 Compute;
+
+protected:
+
+ Image3(int w, int h, WrapMode wrap);
+
+ void copyGImage(const class GImage& im);
+ void copyArray(const Color1* src, int w, int h);
+ void copyArray(const Color3* src, int w, int h);
+ void copyArray(const Color4* src, int w, int h);
+ void copyArray(const Color1uint8* src, int w, int h);
+ void copyArray(const Color3uint8* src, int w, int h);
+ void copyArray(const Color4uint8* src, int w, int h);
+
+public:
+
+ const class ImageFormat* format() const;
+
+ /** Creates an all-zero width x height image. */
+ static Ref createEmpty(int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ /** Creates a 0 x 0 image. */
+ static Ref createEmpty(WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromFile(const std::string& filename, WrapMode wrap = WrapMode::ERROR, GImage::Format fmt = GImage::AUTODETECT);
+
+ static Ref fromArray(const class Color1uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color1* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromImage3uint8(const ReferenceCountedPointer& im);
+
+ static Ref fromGImage(const class GImage& im, WrapMode wrap = WrapMode::ERROR);
+
+ /** Loads from any of the file formats supported by G3D::GImage. If there is an alpha channel on the input,
+ it is stripped. */
+ void load(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Saves in any of the formats supported by G3D::GImage. */
+ void save(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Image3uint8.h b/dep/include/g3dlite/G3D/Image3uint8.h
new file mode 100644
index 000000000..d4fdbc169
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Image3uint8.h
@@ -0,0 +1,85 @@
+/**
+ @file Image3uint8.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2007-01-31
+ @edited 2007-01-31
+*/
+
+#ifndef G3D_IMAGE3UINT8_H
+#define G3D_IMAGE3UINT8_H
+
+#include "G3D/platform.h"
+#include "G3D/Map2D.h"
+#include "G3D/Color3uint8.h"
+#include "G3D/Color3.h"
+#include "G3D/GImage.h"
+
+namespace G3D {
+
+typedef ReferenceCountedPointer Image3uint8Ref;
+
+/**
+ Compact storage for RGB 8-bit per channel images.
+
+ See also G3D::Image3, G3D::GImage
+ */
+class Image3uint8 : public Map2D {
+public:
+
+ typedef Image3uint8 Type;
+ typedef Image3uint8Ref Ref;
+
+protected:
+
+ Image3uint8(int w, int h, WrapMode wrap);
+
+ void copyGImage(const class GImage& im);
+ void copyArray(const Color1* src, int w, int h);
+ void copyArray(const Color3* src, int w, int h);
+ void copyArray(const Color4* src, int w, int h);
+ void copyArray(const Color1uint8* src, int w, int h);
+ void copyArray(const Color3uint8* src, int w, int h);
+ void copyArray(const Color4uint8* src, int w, int h);
+
+public:
+
+ const class ImageFormat* format() const;
+
+ /** Creates an all-zero width x height image. */
+ static Ref createEmpty(int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+
+ /** Creates a 0 x 0 image. */
+ static Ref createEmpty(WrapMode wrap = WrapMode::ERROR);
+
+
+ static Ref fromFile(const std::string& filename, WrapMode wrap = WrapMode::ERROR, GImage::Format fmt = GImage::AUTODETECT);
+
+ static Ref fromGImage(const class GImage& im, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromArray(const class Color1uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color1* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromImage3(const ReferenceCountedPointer& im);
+ static Ref fromImage1uint8(const ReferenceCountedPointer& im);
+
+ /** Loads from any of the file formats supported by G3D::GImage. If there is an alpha channel on the input,
+ it is stripped. */
+ void load(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Saves in any of the formats supported by G3D::GImage. */
+ void save(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Extracts color channel 0 <= c <= 2 and returns it as a new monochrome image. */
+ ReferenceCountedPointer getChannel(int c) const;
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Image4.h b/dep/include/g3dlite/G3D/Image4.h
new file mode 100644
index 000000000..21d7f1e79
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Image4.h
@@ -0,0 +1,86 @@
+/**
+ @file Image4.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2007-01-31
+ @edited 2007-01-31
+*/
+
+
+#ifndef G3D_IMAGE4_H
+#define G3D_IMAGE4_H
+
+#include "G3D/platform.h"
+#include "G3D/Map2D.h"
+#include "G3D/Color4.h"
+#include "G3D/GImage.h"
+
+namespace G3D {
+
+typedef ReferenceCountedPointer Image4Ref;
+
+/**
+ RGBA image with 32-bit floating point storage for each channel.
+
+ Whenever a method needs to convert from RGB to RGBA, A=1 is assumed.
+
+ Bilinear interpolation on Image4 is about 8x faster than on
+ Image4uint8 due to the large cost of converting int->float on modern
+ machines.
+
+ @sa G3D::Image4uint8, G3D::GImage.
+ */
+class Image4 : public Map2D {
+public:
+
+ typedef Image4 Type;
+ typedef ReferenceCountedPointer Ref;
+ typedef Color4 Storage;
+ typedef Color4 Compute;
+
+protected:
+
+ Image4(int w, int h, WrapMode wrap);
+
+ void copyGImage(const class GImage& im);
+ void copyArray(const Color1* src, int w, int h);
+ void copyArray(const Color3* src, int w, int h);
+ void copyArray(const Color4* src, int w, int h);
+ void copyArray(const Color1uint8* src, int w, int h);
+ void copyArray(const Color3uint8* src, int w, int h);
+ void copyArray(const Color4uint8* src, int w, int h);
+
+public:
+
+ const class ImageFormat* format() const;
+
+ /** Creates an all-zero width x height image. */
+ static Ref createEmpty(int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ /** Creates a 0 x 0 image. */
+ static Ref createEmpty(WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromFile(const std::string& filename, WrapMode wrap = WrapMode::ERROR, GImage::Format fmt = GImage::AUTODETECT);
+
+ static Ref fromArray(const class Color1uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color1* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromImage4uint8(const ReferenceCountedPointer& im);
+
+ static Ref fromGImage(const class GImage& im, WrapMode wrap = WrapMode::ERROR);
+
+ /** Loads from any of the file formats supported by G3D::GImage. */
+ void load(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Saves in any of the formats supported by G3D::GImage. */
+ void save(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Image4uint8.h b/dep/include/g3dlite/G3D/Image4uint8.h
new file mode 100644
index 000000000..46df6b490
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Image4uint8.h
@@ -0,0 +1,85 @@
+/**
+ @file Image4uint8.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2007-01-31
+ @edited 2007-01-31
+*/
+
+#ifndef G3D_IMAGE4UINT8_H
+#define G3D_IMAGE4UINT8_H
+
+#include "G3D/platform.h"
+#include "G3D/Map2D.h"
+#include "G3D/Color4uint8.h"
+#include "G3D/Color4.h"
+#include "G3D/GImage.h"
+#include "G3D/Image1uint8.h"
+
+namespace G3D {
+
+typedef ReferenceCountedPointer Image4uint8Ref;
+
+/**
+ Compact storage for RGBA 8-bit per channel images.
+
+ See also G3D::Image4, G3D::GImage
+ */
+class Image4uint8 : public Map2D {
+public:
+
+ typedef Image4uint8 Type;
+ typedef Image4uint8Ref Ref;
+
+protected:
+
+ Image4uint8(int w, int h, WrapMode wrap);
+
+ void copyGImage(const class GImage& im);
+ void copyArray(const Color1* src, int w, int h);
+ void copyArray(const Color3* src, int w, int h);
+ void copyArray(const Color4* src, int w, int h);
+ void copyArray(const Color1uint8* src, int w, int h);
+ void copyArray(const Color3uint8* src, int w, int h);
+ void copyArray(const Color4uint8* src, int w, int h);
+
+public:
+
+ const class ImageFormat* format() const;
+
+ /** Creates an all-zero width x height image. */
+ static Ref createEmpty(int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+
+ /** Creates a 0 x 0 image. */
+ static Ref createEmpty(WrapMode wrap = WrapMode::ERROR);
+
+
+ static Ref fromFile(const std::string& filename, WrapMode wrap = WrapMode::ERROR, GImage::Format fmt = GImage::AUTODETECT);
+
+ static Ref fromGImage(const class GImage& im, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromArray(const class Color1uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4uint8* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color1* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color3* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+ static Ref fromArray(const class Color4* ptr, int width, int height, WrapMode wrap = WrapMode::ERROR);
+
+ static Ref fromImage4(const ReferenceCountedPointer& im);
+
+ /** Loads from any of the file formats supported by G3D::GImage. If there is an alpha channel on the input,
+ it is stripped. */
+ void load(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Saves in any of the formats supported by G3D::GImage. */
+ void save(const std::string& filename, GImage::Format fmt = GImage::AUTODETECT);
+
+ /** Extracts color channel 0 <= c <= 3 and returns it as a new monochrome image. */
+ ReferenceCountedPointer getChannel(int c) const;
+};
+
+} // G3D
+
+#endif
diff --git a/dep/include/g3dlite/G3D/ImageFormat.h b/dep/include/g3dlite/G3D/ImageFormat.h
new file mode 100644
index 000000000..7f098322d
--- /dev/null
+++ b/dep/include/g3dlite/G3D/ImageFormat.h
@@ -0,0 +1,419 @@
+/**
+ @file ImageFormat.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-05-23
+ @edited 2010-01-01
+*/
+
+#ifndef GLG3D_ImageFormat_H
+#define GLG3D_ImageFormat_H
+
+#include "G3D/platform.h"
+#include "G3D/Table.h"
+#include "G3D/enumclass.h"
+
+namespace G3D {
+
+/** Information about common image formats.
+ Don't construct these; use the methods provided.
+
+ For most formats, the number indicates the number of bits per channel and a suffix of "F" indicates
+ floating point. This does not hold for the YUV and DXT formats.*/
+class ImageFormat {
+public:
+
+ // Must update ImageFormat::name() when this enum changes.
+ enum Code {
+ CODE_NONE = -1,
+ CODE_L8,
+ CODE_L16,
+ CODE_L16F,
+ CODE_L32F,
+
+ CODE_A8,
+ CODE_A16,
+ CODE_A16F,
+ CODE_A32F,
+
+ CODE_LA4,
+ CODE_LA8,
+ CODE_LA16,
+ CODE_LA16F,
+ CODE_LA32F,
+
+ CODE_RGB5,
+ CODE_RGB5A1,
+ CODE_RGB8,
+ CODE_RGB10,
+ CODE_RGB10A2,
+ CODE_RGB16,
+ CODE_RGB16F,
+ CODE_RGB32F,
+ CODE_R11G11B10F,
+ CODE_RGB9E5F,
+
+ CODE_RGB8I,
+ CODE_RGB8UI,
+
+ CODE_ARGB8,
+ CODE_BGR8,
+
+ CODE_RG8,
+ CODE_RG8I,
+ CODE_RG8UI,
+
+ CODE_RGBA8,
+ CODE_RGBA16,
+ CODE_RGBA16F,
+ CODE_RGBA32F,
+
+ CODE_RGBA32UI,
+
+ CODE_BAYER_RGGB8,
+ CODE_BAYER_GRBG8,
+ CODE_BAYER_GBRG8,
+ CODE_BAYER_BGGR8,
+ CODE_BAYER_RGGB32F,
+ CODE_BAYER_GRBG32F,
+ CODE_BAYER_GBRG32F,
+ CODE_BAYER_BGGR32F,
+
+ CODE_HSV8,
+ CODE_HSV32F,
+
+ CODE_YUV420_PLANAR,
+ CODE_YUV422,
+ CODE_YUV444,
+
+ CODE_RGB_DXT1,
+ CODE_RGBA_DXT1,
+ CODE_RGBA_DXT3,
+ CODE_RGBA_DXT5,
+
+ CODE_SRGB8,
+ CODE_SRGBA8,
+
+ CODE_SL8,
+ CODE_SLA8,
+
+ CODE_SRGB_DXT1,
+ CODE_SRGBA_DXT1,
+ CODE_SRGBA_DXT3,
+ CODE_SRGBA_DXT5,
+
+ CODE_DEPTH16,
+ CODE_DEPTH24,
+ CODE_DEPTH32,
+ CODE_DEPTH32F,
+
+ CODE_STENCIL1,
+ CODE_STENCIL4,
+ CODE_STENCIL8,
+ CODE_STENCIL16,
+
+ CODE_DEPTH24_STENCIL8,
+
+ CODE_NUM
+ };
+
+ enum ColorSpace {
+ COLOR_SPACE_NONE,
+ COLOR_SPACE_RGB,
+ COLOR_SPACE_HSV,
+ COLOR_SPACE_YUV,
+ COLOR_SPACE_SRGB
+ };
+
+ enum BayerPattern {
+ BAYER_PATTERN_NONE,
+ BAYER_PATTERN_RGGB,
+ BAYER_PATTERN_GRBG,
+ BAYER_PATTERN_GBRG,
+ BAYER_PATTERN_BGGR
+ };
+
+ /** Number of channels (1 for a depth texture). */
+ int numComponents;
+ bool compressed;
+
+ /** Useful for serializing. */
+ Code code;
+
+ ColorSpace colorSpace;
+
+ /** If this is a Bayer format, what is the pattern. */
+ BayerPattern bayerPattern;
+
+ /** The OpenGL format equivalent to this one, e.g, GL_RGB8 Zero if there is no equivalent. This is actually a GLenum */
+ int openGLFormat;
+
+ /** The OpenGL base format equivalent to this one (e.g., GL_RGB, GL_ALPHA). Zero if there is no equivalent. */
+ int openGLBaseFormat;
+
+ int luminanceBits;
+
+ /** Number of bits per pixel storage for alpha values; Zero for compressed textures and non-RGB. */
+ int alphaBits;
+
+ /** Number of bits per pixel storage for red values; Zero for compressed textures and non-RGB. */
+ int redBits;
+
+ /** Number of bits per pixel storage for green values; Zero for compressed textures and non-RGB. */
+ int greenBits;
+
+ /** Number of bits per pixel storage for blue values; Zero for compressed textures and non-RGB. */
+ int blueBits;
+
+ /** Number of bits per pixel */
+ int stencilBits;
+
+ /** Number of depth bits (for depth textures; e.g. shadow maps) */
+ int depthBits;
+
+ /** Amount of CPU memory per pixel when packed into an array, discounting any end-of-row padding. */
+ int cpuBitsPerPixel;
+
+ /** Amount of CPU memory per pixel when packed into an array, discounting any end-of-row padding.
+ @deprecated Use cpuBitsPerPixel*/
+ int packedBitsPerTexel;
+
+ /**
+ Amount of GPU memory per pixel on most graphics cards, for formats supported by OpenGL. This is
+ only an estimate--the actual amount of memory may be different on your actual card.
+
+ This may be greater than the sum of the per-channel bits
+ because graphics cards need to pad to the nearest 1, 2, or
+ 4 bytes.
+ */
+ int openGLBitsPerPixel;
+
+ /** @deprecated Use openGLBitsPerPixel */
+ int hardwareBitsPerTexel;
+
+ /** The OpenGL bytes (type) format of the data buffer used with this texture format, e.g., GL_UNSIGNED_BYTE */
+ int openGLDataFormat;
+
+ /** True if there is no alpha channel for this texture. */
+ bool opaque;
+
+ /** True if the bit depths specified are for float formats. */
+ bool floatingPoint;
+
+ /** Human readable name of this format.*/
+ const std::string& name() const;
+
+ /** Takes the same values that name() returns */
+ static const ImageFormat* fromString(const std::string& s);
+
+private:
+
+ ImageFormat
+ (int numComponents,
+ bool compressed,
+ int glFormat,
+ int glBaseFormat,
+ int luminanceBits,
+ int alphaBits,
+ int redBits,
+ int greenBits,
+ int blueBits,
+ int depthBits,
+ int stencilBits,
+ int hardwareBitsPerTexel,
+ int packedBitsPerTexel,
+ int glDataFormat,
+ bool opaque,
+ bool floatingPoint,
+ Code code,
+ ColorSpace colorSpace,
+ BayerPattern bayerPattern = BAYER_PATTERN_NONE);
+
+public:
+
+ static const ImageFormat* L8();
+
+ static const ImageFormat* L16();
+
+ static const ImageFormat* L16F();
+
+ static const ImageFormat* L32F();
+
+ static const ImageFormat* A8();
+
+ static const ImageFormat* A16();
+
+ static const ImageFormat* A16F();
+
+ static const ImageFormat* A32F();
+
+ static const ImageFormat* LA4();
+
+ static const ImageFormat* LA8();
+
+ static const ImageFormat* LA16();
+
+ static const ImageFormat* LA16F();
+
+ static const ImageFormat* LA32F();
+
+ static const ImageFormat* BGR8();
+
+ static const ImageFormat* RG8();
+ static const ImageFormat* RG8I();
+ static const ImageFormat* RG8UI();
+
+ static const ImageFormat* RGB5();
+
+ static const ImageFormat* RGB5A1();
+
+ static const ImageFormat* RGB8();
+
+ static const ImageFormat* RGB10();
+
+ static const ImageFormat* RGB10A2();
+
+ static const ImageFormat* RGB16();
+
+ static const ImageFormat* RGB16F();
+
+ static const ImageFormat* RGB32F();
+
+ static const ImageFormat* RGBA8();
+
+ static const ImageFormat* RGBA16();
+
+ static const ImageFormat* RGBA16F();
+
+ static const ImageFormat* RGBA32F();
+
+ static const ImageFormat* RGBA32UI();
+
+ static const ImageFormat* R11G11B10F();
+
+ static const ImageFormat* RGB9E5F();
+
+ static const ImageFormat* RGB8I();
+
+ static const ImageFormat* RGB8UI();
+
+ static const ImageFormat* RGB_DXT1();
+
+ static const ImageFormat* RGBA_DXT1();
+
+ static const ImageFormat* RGBA_DXT3();
+
+ static const ImageFormat* RGBA_DXT5();
+
+ static const ImageFormat* SRGB8();
+
+ static const ImageFormat* SRGBA8();
+
+ static const ImageFormat* SL8();
+
+ static const ImageFormat* SLA8();
+
+ static const ImageFormat* SRGB_DXT1();
+
+ static const ImageFormat* SRGBA_DXT1();
+
+ static const ImageFormat* SRGBA_DXT3();
+
+ static const ImageFormat* SRGBA_DXT5();
+
+ static const ImageFormat* DEPTH16();
+
+ static const ImageFormat* DEPTH24();
+
+ static const ImageFormat* DEPTH32();
+
+ static const ImageFormat* DEPTH32F();
+
+ static const ImageFormat* STENCIL1();
+
+ static const ImageFormat* STENCIL4();
+
+ static const ImageFormat* STENCIL8();
+
+ static const ImageFormat* STENCIL16();
+
+ static const ImageFormat* DEPTH24_STENCIL8();
+
+ static const ImageFormat* YUV420_PLANAR();
+
+ static const ImageFormat* YUV422();
+
+ static const ImageFormat* YUV444();
+
+ /**
+ NULL pointer; indicates that the G3D::Texture class should choose
+ either RGBA8 or RGB8 depending on the presence of an alpha channel
+ in the input.
+ */
+ static const ImageFormat* AUTO() { return NULL; }
+
+ /** Returns DEPTH16, DEPTH24, or DEPTH32 according to the bits
+ specified. You can use "glGetInteger(GL_DEPTH_BITS)" to match
+ the screen's format.*/
+ static const ImageFormat* depth(int depthBits = 24);
+
+ /** Returns STENCIL1, STENCIL4, STENCIL8 or STENCIL16 according to the bits
+ specified. You can use "glGetInteger(GL_STENCIL_BITS)" to match
+ the screen's format.*/
+ static const ImageFormat* stencil(int bits = 8);
+
+ /** Returns the matching ImageFormat* identified by the Code. May return NULL
+ if this format's code is reserved but not yet implemented by G3D. */
+ static const ImageFormat* fromCode(ImageFormat::Code code);
+
+
+
+ /** For use with ImageFormat::convert. */
+ class BayerAlgorithm {
+ public:
+ enum Value {
+ NEAREST,
+ BILINEAR,
+ MHC,
+ HIGH_QUALITY = MHC
+ };
+ private:
+
+ Value value;
+
+ public:
+
+ G3D_DECLARE_ENUM_CLASS_METHODS(BayerAlgorithm);
+ };
+
+ /** Converts between arbitrary formats on the CPU. Not all format conversions are supported or directly supported.
+ Formats without direct conversions will attempt to convert through RGBA first.
+
+ A conversion routine might only support source or destination padding or y inversion or none.
+ If support is needed and not available in any of the direct conversion routines, then no conversion is done.
+
+ YUV422 expects data in YUY2 format (Y, U, Y2, v). Most YUV formats require width and heights that are multiples of 2.
+
+ Returns true if a conversion was available, false if none occurred.
+ */
+ static bool convert(const Array& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits,
+ const Array& dstBytes, const ImageFormat* dstFormat, int dstRowPadBits,
+ bool invertY = false, BayerAlgorithm bayerAlg = BayerAlgorithm::HIGH_QUALITY);
+
+ /* Checks if a conversion between two formats is available. */
+ static bool conversionAvailable(const ImageFormat* srcFormat, int srcRowPadBits, const ImageFormat* dstFormat, int dstRowPadBits, bool invertY = false);
+};
+
+typedef ImageFormat TextureFormat;
+
+}
+
+template <>
+struct HashTrait {
+ static size_t hashCode(const G3D::ImageFormat* key) { return reinterpret_cast(key); }
+};
+
+
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Intersect.h b/dep/include/g3dlite/G3D/Intersect.h
new file mode 100644
index 000000000..4a3c8fb45
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Intersect.h
@@ -0,0 +1,55 @@
+/**
+ @file Intersect.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2009-06-29
+ @edited 2009-06-29
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+
+ From the G3D Innovation Engine
+ http://g3d.sf.net
+ */
+#ifndef G3D_Intersect
+#define G3D_Intersect
+
+#include "G3D/platform.h"
+#include "G3D/Ray.h"
+#include "G3D/AABox.h"
+
+namespace G3D {
+
+/**
+ @beta
+ */
+class Intersect {
+public:
+
+ /** \brief Returns true if the intersection of the ray and the solid box is non-empty.
+
+ \cite "Fast Ray / Axis-Aligned Bounding Box Overlap Tests using Ray Slopes"
+ by Martin Eisemann, Thorsten Grosch, Stefan Mller and Marcus Magnor
+ Computer Graphics Lab, TU Braunschweig, Germany and
+ University of Koblenz-Landau, Germany
+ */
+ static bool __fastcall rayAABox(const Ray& ray, const AABox& box);
+
+ /** \brief Returns true if the intersection of the ray and the solid box is non-empty.
+
+ \param time If there is an intersection, set to the time to that intersection. If the ray origin is inside the box,
+ this is a negative value indicating the distance backwards from the ray origin to the first intersection.
+ \a time is not set if there is no intersection.
+
+ \cite Slope-Mul method from "Fast Ray / Axis-Aligned Bounding Box Overlap Tests using Ray Slopes"
+ by Martin Eisemann, Thorsten Grosch, Stefan Mller and Marcus Magnor
+ Computer Graphics Lab, TU Braunschweig, Germany and
+ University of Koblenz-Landau, Germany
+ */
+ static bool __fastcall rayAABox(const Ray& ray, const AABox& box, float& time);
+};
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/KDTree.h b/dep/include/g3dlite/G3D/KDTree.h
new file mode 100644
index 000000000..4785ef2ba
--- /dev/null
+++ b/dep/include/g3dlite/G3D/KDTree.h
@@ -0,0 +1,1667 @@
+/**
+ @file KDTree.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2004-01-11
+ @edited 2009-12-28
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+
+#ifndef G3D_KDTREE_H
+#define G3D_KDTREE_H
+
+#include "G3D/platform.h"
+#include "G3D/Array.h"
+#include "G3D/Table.h"
+#include "G3D/Vector2.h"
+#include "G3D/Vector3.h"
+#include "G3D/Vector4.h"
+#include "G3D/AABox.h"
+#include "G3D/Sphere.h"
+#include "G3D/Box.h"
+#include "G3D/Triangle.h"
+#include "G3D/Ray.h"
+#include "G3D/GCamera.h"
+#include "G3D/BinaryInput.h"
+#include "G3D/BinaryOutput.h"
+#include "G3D/CollisionDetection.h"
+#include "G3D/GCamera.h"
+#include "G3D/BoundsTrait.h"
+#include
+
+// If defined, in debug mode the tree is checked for consistency
+// as a way of detecting corruption due to implementation bugs
+// #define VERIFY_TREE
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Vector2& v, G3D::AABox& out) { out = G3D::AABox(G3D::Vector3(v, 0)); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Vector3& v, G3D::AABox& out) { out = G3D::AABox(v); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Vector4& v, G3D::AABox& out) { out = G3D::AABox(v.xyz()); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::AABox& v, G3D::AABox& out) { out = v; }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Sphere& s, G3D::AABox& out) { s.getBounds(out); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Box& b, G3D::AABox& out) { b.getBounds(out); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Vector2*& v, G3D::AABox& out) { out = G3D::AABox(G3D::Vector3(*v, 0)); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Vector3*& v, G3D::AABox& out) { out = G3D::AABox(*v); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Vector4*& v, G3D::AABox& out) { out = G3D::AABox(v->xyz()); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::AABox*& v, G3D::AABox& out) { out = *v; }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Sphere*& s, G3D::AABox& out) { s->getBounds(out); }
+};
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Box*& b, G3D::AABox& out) { b->getBounds(out); }
+};
+
+
+template<> struct BoundsTrait {
+ static void getBounds(const G3D::Triangle*& t, G3D::AABox& out) { t->getBounds(out); }
+};
+
+namespace G3D {
+ namespace _internal {
+
+ /**
+ Wraps a pointer value so that it can be treated as the instance itself;
+ convenient for inserting pointers into a Table but using the
+ object equality instead of pointer equality.
+ */
+ template
+ class Indirector {
+ public:
+ Type* handle;
+
+ inline Indirector(Type* h) : handle(h) {}
+
+ inline Indirector() : handle(NULL) {}
+
+ /** Returns true iff the values referenced by the handles are equivalent. */
+ inline bool operator==(const Indirector& m) const {
+ return *handle == *(m.handle);
+ }
+
+ inline bool operator==(const Type& m) const {
+ return *handle == m;
+ }
+
+ inline size_t hashCode() const {
+ return handle->hashCode();
+ }
+ };
+ } // namespace internal
+} // namespace G3D
+
+template struct HashTrait > {
+ static size_t hashCode(const G3D::_internal::Indirector& key) { return key.hashCode(); }
+};
+
+namespace G3D {
+
+/**
+ A set that supports spatial queries using a KD tree (axis-aligned
+ BSP tree) for speed.
+
+ KDTree allows you to quickly find objects in 3D that lie within
+ a box or along a ray. For large sets of objects it is much faster
+ than testing each object for a collision.
+
+ KDTree is as powerful as but more general than a Quad Tree, Oct
+ Tree, or regular KD tree that cycles through axes, but less general than an unconstrained BSP tree
+ (which is much slower to create).
+
+ Internally, objects
+ are arranged into a tree according to their
+ axis-aligned bounds. This increases the cost of insertion to
+ O(log n) but allows fast overlap queries.
+
+ Template Parameters
+ The template parameter T must be one for which
+ the following functions are all overloaded:
+
+
+ T::T(); // public constructor of no arguments
+ template <> struct HashTrait { static size_t hashCode(int key); };
+ template<> struct BoundsTrait { static void getBounds(const T& obj, G3D::AABox& out); };
+
+
+ G3D provides these for common classes like G3D::Vector3 and G3D::Sphere.
+ If you use a custom class, or a pointer to a custom class, you will need
+ to define those functions.
+
+ Moving %Set Members
+ It is important that objects do not move without updating the
+ KDTree. If the axis-aligned bounds of an object are about
+ to change, KDTree::remove it before they change and
+ KDTree::insert it again afterward. For objects
+ where the hashCode and == operator are invariant with respect
+ to the 3D position,
+ you can use the KDTree::update method as a shortcut to
+ insert/remove an object in one step after it has moved.
+
+
+ Note: Do not mutate any value once it has been inserted into KDTree. Values
+ are copied interally. All KDTree iterators convert to pointers to constant
+ values to reinforce this.
+
+ If you want to mutate the objects you intend to store in a KDTree
+ simply insert pointers to your objects instead of the objects
+ themselves, and ensure that the above operations are defined. (And
+ actually, because values are copied, if your values are large you may
+ want to insert pointers anyway, to save space and make the balance
+ operation faster.)
+
+ Dimensions
+ Although designed as a 3D-data structure, you can use the KDTree
+ for data distributed along 2 or 1 axes by simply returning bounds
+ that are always zero along one or more dimensions.
+
+*/
+template< class T,
+ class BoundsFunc = BoundsTrait,
+ class HashFunc = HashTrait,
+ class EqualsFunc = EqualsTrait >
+class KDTree {
+protected:
+#define TreeType KDTree
+
+ /** Wrapper for a value that includes a cache of its bounds.
+ Except for the test value used in a set-query operation, there
+ is only ever one instance of the handle associated with any
+ value and the memberTable and Nodes maintain pointers to that
+ heap-allocated value.
+ */
+ class Handle {
+ public:
+ /** The bounds of each object are constrained to AABox::large */
+ AABox bounds;
+
+ /** Center of bounds. We cache this value to avoid recomputing it
+ during the median sort, and because MSVC 6 std::sort goes into
+ an infinite loop if we compute the midpoint on the fly (possibly
+ a floating point roundoff issue, where B& point,
+ int beginIndex,
+ int endIndex) {
+
+ Vector3 lo = Vector3::inf();
+ Vector3 hi = -lo;
+
+ debugAssertM(beginIndex <= endIndex, "No points");
+ for (int p = beginIndex; p <= endIndex; ++p) {
+ // This code is written with the vector min and max expanded
+ // because otherwise it compiles incorrectly with -O3 on
+ // gcc 3.4
+
+ const Vector3& pLo = point[p]->bounds.low();
+ const Vector3& pHi = point[p]->bounds.high();
+ for (int a = 0; a < 3; ++a) {
+ lo[a] = G3D::min(lo[a], pLo[a]);
+ hi[a] = G3D::max(hi[a], pHi[a]);
+ }
+ }
+
+ return AABox(lo, hi);
+ }
+
+ /** Compares centers */
+ class CenterComparator {
+ public:
+ Vector3::Axis sortAxis;
+
+ CenterComparator(Vector3::Axis a) : sortAxis(a) {}
+
+ inline int operator()(Handle* A, const Handle* B) const {
+ float a = A->center[sortAxis];
+ float b = B->center[sortAxis];
+
+ if (a < b) {
+ return 1;
+ } else if (a > b) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ };
+
+
+ /** Compares bounds for strict >, <, or overlap*/
+ class BoundsComparator {
+ public:
+ Vector3::Axis sortAxis;
+
+ BoundsComparator(Vector3::Axis a) : sortAxis(a) {}
+
+ inline int operator()(Handle* A, const Handle* B) const {
+ const AABox& a = A->bounds;
+ const AABox& b = B->bounds;
+
+ if (a.high()[sortAxis] < b.low()[sortAxis]) {
+ return 1;
+ } else if (a.low()[sortAxis] > b.high()[sortAxis]) {
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ };
+
+
+ /** Compares bounds to the sort location */
+ class Comparator {
+ public:
+ Vector3::Axis sortAxis;
+ float sortLocation;
+
+ Comparator(Vector3::Axis a, float l) : sortAxis(a), sortLocation(l) {}
+
+ inline int operator()(Handle* ignore, const Handle* handle) const {
+ (void)ignore;
+ const AABox& box = handle->bounds;
+ debugAssert(ignore == NULL);
+
+ if (box.high()[sortAxis] < sortLocation) {
+ // Box is strictly below the sort location
+ return -1;
+ } else if (box.low()[sortAxis] > sortLocation) {
+ // Box is strictly above the sort location
+ return 1;
+ } else {
+ // Box overlaps the sort location
+ return 0;
+ }
+ }
+ };
+
+ // Using System::malloc with this class provided no speed improvement.
+ class Node {
+ public:
+
+ /** Spatial bounds on all values at this node and its children, based purely on
+ the parent's splitting planes. May be infinite. */
+ AABox splitBounds;
+
+ Vector3::Axis splitAxis;
+
+ /** Location along the specified axis */
+ float splitLocation;
+
+ /** child[0] contains all values strictly
+ smaller than splitLocation along splitAxis.
+
+ child[1] contains all values strictly
+ larger.
+
+ Both may be NULL if there are not enough
+ values to bother recursing.
+ */
+ Node* child[2];
+
+ /** Array of values at this node (i.e., values
+ straddling the split plane + all values if
+ this is a leaf node).
+
+ This is an array of pointers because that minimizes
+ data movement during tree building, which accounts
+ for about 15% of the time cost of tree building.
+ */
+ Array valueArray;
+
+ /** For each object in the value array, a copy of its bounds.
+ Packing these into an array at the node level
+ instead putting them in the valueArray improves
+ cache coherence, which is about a 3x performance
+ increase when performing intersection computations.
+ */
+ Array boundsArray;
+
+ /** Creates node with NULL children */
+ Node() {
+ splitAxis = Vector3::X_AXIS;
+ splitLocation = 0;
+ splitBounds = AABox(-Vector3::inf(), Vector3::inf());
+ for (int i = 0; i < 2; ++i) {
+ child[i] = NULL;
+ }
+ }
+
+ /**
+ Doesn't clone children.
+ */
+ Node(const Node& other) : valueArray(other.valueArray), boundsArray(other.boundsArray) {
+ splitAxis = other.splitAxis;
+ splitLocation = other.splitLocation;
+ splitBounds = other.splitBounds;
+ for (int i = 0; i < 2; ++i) {
+ child[i] = NULL;
+ }
+ }
+
+ /** Copies the specified subarray of pt into point, NULLs the children.
+ Assumes a second pass will set splitBounds. */
+ Node(const Array& pt) : valueArray(pt) {
+ splitAxis = Vector3::X_AXIS;
+ splitLocation = 0;
+ for (int i = 0; i < 2; ++i) {
+ child[i] = NULL;
+ }
+
+ boundsArray.resize(valueArray.size());
+ for (int i = 0; i < valueArray.size(); ++i) {
+ boundsArray[i] = valueArray[i]->bounds;
+ }
+ }
+
+ /** Deletes the children (but not the values) */
+ ~Node() {
+ for (int i = 0; i < 2; ++i) {
+ delete child[i];
+ }
+ }
+
+ /** Returns true if this node is a leaf (no children) */
+ inline bool isLeaf() const {
+ return (child[0] == NULL) && (child[1] == NULL);
+ }
+
+
+ /**
+ Recursively appends all handles and children's handles
+ to the array.
+ */
+ void getHandles(Array& handleArray) const {
+ handleArray.append(valueArray);
+ for (int i = 0; i < 2; ++i) {
+ if (child[i] != NULL) {
+ child[i]->getHandles(handleArray);
+ }
+ }
+ }
+
+ void verifyNode(const Vector3& lo, const Vector3& hi) {
+ // debugPrintf("Verifying: split %d @ %f [%f, %f, %f], [%f, %f, %f]\n",
+ // splitAxis, splitLocation, lo.x, lo.y, lo.z, hi.x, hi.y, hi.z);
+
+ debugAssertM(lo == splitBounds.low(),
+ format("lo = %s, splitBounds.lo = %s",
+ lo.toString().c_str(), splitBounds.low().toString().c_str()));
+ debugAssert(hi == splitBounds.high());
+
+ for (int i = 0; i < valueArray.length(); ++i) {
+ const AABox& b = valueArray[i]->bounds;
+ debugAssert(b == boundsArray[i]);
+
+ for(int axis = 0; axis < 3; ++axis) {
+ debugAssert(b.low()[axis] <= b.high()[axis]);
+ debugAssert(b.low()[axis] >= lo[axis]);
+ debugAssert(b.high()[axis] <= hi[axis]);
+ }
+ }
+
+ if (child[0] || child[1]) {
+ debugAssert(lo[splitAxis] < splitLocation);
+ debugAssert(hi[splitAxis] > splitLocation);
+ }
+
+ Vector3 newLo = lo;
+ newLo[splitAxis] = splitLocation;
+ Vector3 newHi = hi;
+ newHi[splitAxis] = splitLocation;
+
+ if (child[0] != NULL) {
+ child[0]->verifyNode(lo, newHi);
+ }
+
+ if (child[1] != NULL) {
+ child[1]->verifyNode(newLo, hi);
+ }
+ }
+
+
+ /**
+ Stores the locations of the splitting planes (the structure but not the content)
+ so that the tree can be quickly rebuilt from a previous configuration without
+ calling balance.
+ */
+ static void serializeStructure(const Node* n, BinaryOutput& bo) {
+ if (n == NULL) {
+ bo.writeUInt8(0);
+ } else {
+ bo.writeUInt8(1);
+ n->splitBounds.serialize(bo);
+ serialize(n->splitAxis, bo);
+ bo.writeFloat32(n->splitLocation);
+ for (int c = 0; c < 2; ++c) {
+ serializeStructure(n->child[c], bo);
+ }
+ }
+ }
+
+ /** Clears the member table */
+ static Node* deserializeStructure(BinaryInput& bi) {
+ if (bi.readUInt8() == 0) {
+ return NULL;
+ } else {
+ Node* n = new Node();
+ n->splitBounds.deserialize(bi);
+ deserialize(n->splitAxis, bi);
+ n->splitLocation = bi.readFloat32();
+ for (int c = 0; c < 2; ++c) {
+ n->child[c] = deserializeStructure(bi);
+ }
+ return n;
+ }
+ }
+
+ /** Returns the deepest node that completely contains bounds. */
+ Node* findDeepestContainingNode(const AABox& bounds) {
+
+ // See which side of the splitting plane the bounds are on
+ if (bounds.high()[splitAxis] < splitLocation) {
+ // Bounds are on the low side. Recurse into the child
+ // if it exists.
+ if (child[0] != NULL) {
+ return child[0]->findDeepestContainingNode(bounds);
+ }
+ } else if (bounds.low()[splitAxis] > splitLocation) {
+ // Bounds are on the high side, recurse into the child
+ // if it exists.
+ if (child[1] != NULL) {
+ return child[1]->findDeepestContainingNode(bounds);
+ }
+ }
+
+ // There was no containing child, so this node is the
+ // deepest containing node.
+ return this;
+ }
+
+
+ /** Appends all members that intersect the box.
+ If useSphere is true, members that pass the box test
+ face a second test against the sphere. */
+ void getIntersectingMembers(
+ const AABox& box,
+ const Sphere& sphere,
+ Array& members,
+ bool useSphere) const {
+
+ // Test all values at this node
+ for (int v = 0; v < boundsArray.size(); ++v) {
+ const AABox& bounds = boundsArray[v];
+ if (bounds.intersects(box) &&
+ (! useSphere || bounds.intersects(sphere))) {
+ members.append(& (valueArray[v]->value));
+ }
+ }
+
+ // If the left child overlaps the box, recurse into it
+ if ((child[0] != NULL) && (box.low()[splitAxis] < splitLocation)) {
+ child[0]->getIntersectingMembers(box, sphere, members, useSphere);
+ }
+
+ // If the right child overlaps the box, recurse into it
+ if ((child[1] != NULL) && (box.high()[splitAxis] > splitLocation)) {
+ child[1]->getIntersectingMembers(box, sphere, members, useSphere);
+ }
+ }
+
+ /**
+ Recurse through the tree, assigning splitBounds fields.
+ */
+ void assignSplitBounds(const AABox& myBounds) {
+ splitBounds = myBounds;
+
+ AABox childBounds[2];
+ myBounds.split(splitAxis, splitLocation, childBounds[0], childBounds[1]);
+
+# if defined(G3D_DEBUG) && defined(VERIFY_TREE)
+ // Verify the split
+ for (int v = 0; v < boundsArray.size(); ++v) {
+ const AABox& bounds = boundsArray[v];
+ debugAssert(myBounds.contains(bounds));
+ }
+# endif
+
+ for (int c = 0; c < 2; ++c) {
+ if (child[c]) {
+ child[c]->assignSplitBounds(childBounds[c]);
+ }
+ }
+ }
+
+ /** Returns true if the ray intersects this node */
+ bool intersects(const Ray& ray, float distance) const {
+ // See if the ray will ever hit this node or its children
+ Vector3 location;
+ bool alreadyInsideBounds = false;
+ bool rayWillHitBounds =
+ CollisionDetection::collisionLocationForMovingPointFixedAABox(
+ ray.origin(), ray.direction(), splitBounds, location, alreadyInsideBounds);
+
+ bool canHitThisNode = (alreadyInsideBounds ||
+ (rayWillHitBounds && ((location - ray.origin()).squaredLength() < square(distance))));
+
+ return canHitThisNode;
+ }
+
+ template
+ void intersectRay(
+ const Ray& ray,
+ RayCallback& intersectCallback,
+ float& distance,
+ bool intersectCallbackIsFast) const {
+
+ if (! intersects(ray, distance)) {
+ // The ray doesn't hit this node, so it can't hit the children of the node.
+ return;
+ }
+
+ // Test for intersection against every object at this node.
+ for (int v = 0; v < valueArray.size(); ++v) {
+ bool canHitThisObject = true;
+
+ if (! intersectCallbackIsFast) {
+ // See if
+ Vector3 location;
+ const AABox& bounds = boundsArray[v];
+ bool alreadyInsideBounds = false;
+ bool rayWillHitBounds =
+ CollisionDetection::collisionLocationForMovingPointFixedAABox(
+ ray.origin(), ray.direction(), bounds, location, alreadyInsideBounds);
+
+ canHitThisObject = (alreadyInsideBounds ||
+ (rayWillHitBounds && ((location - ray.origin()).squaredLength() < square(distance))));
+ }
+
+ if (canHitThisObject) {
+ // It is possible that this ray hits this object. Look for the intersection using the
+ // callback.
+ const T& value = valueArray[v]->value;
+ intersectCallback(ray, value, distance);
+ }
+ }
+
+ // There are three cases to consider next:
+ //
+ // 1. the ray can start on one side of the splitting plane and never enter the other,
+ // 2. the ray can start on one side and enter the other, and
+ // 3. the ray can travel exactly down the splitting plane
+
+ enum {NONE = -1};
+ int firstChild = NONE;
+ int secondChild = NONE;
+
+ if (ray.origin()[splitAxis] < splitLocation) {
+
+ // The ray starts on the small side
+ firstChild = 0;
+
+ if (ray.direction()[splitAxis] > 0) {
+ // The ray will eventually reach the other side
+ secondChild = 1;
+ }
+
+ } else if (ray.origin()[splitAxis] > splitLocation) {
+
+ // The ray starts on the large side
+ firstChild = 1;
+
+ if (ray.direction()[splitAxis] < 0) {
+ secondChild = 0;
+ }
+ } else {
+ // The ray starts on the splitting plane
+ if (ray.direction()[splitAxis] < 0) {
+ // ...and goes to the small side
+ firstChild = 0;
+ } else if (ray.direction()[splitAxis] > 0) {
+ // ...and goes to the large side
+ firstChild = 1;
+ }
+ }
+
+ // Test on the side closer to the ray origin.
+ if ((firstChild != NONE) && child[firstChild]) {
+ child[firstChild]->intersectRay(ray, intersectCallback, distance, intersectCallbackIsFast);
+ }
+
+ if (ray.direction()[splitAxis] != 0) {
+ // See if there was an intersection before hitting the splitting plane.
+ // If so, there is no need to look on the far side and recursion terminates.
+ float distanceToSplittingPlane = (splitLocation - ray.origin()[splitAxis]) / ray.direction()[splitAxis];
+ if (distanceToSplittingPlane > distance) {
+ // We aren't going to hit anything else before hitting the splitting plane,
+ // so don't bother looking on the far side of the splitting plane at the other
+ // child.
+ return;
+ }
+ }
+
+ // Test on the side farther from the ray origin.
+ if ((secondChild != NONE) && child[secondChild]) {
+ child[secondChild]->intersectRay(ray, intersectCallback, distance, intersectCallbackIsFast);
+ }
+
+ }
+ };
+
+
+ /**
+ Recursively subdivides the subarray.
+
+ Clears the source array as soon as it is no longer needed.
+
+ Call assignSplitBounds() on the root node after making a tree.
+ */
+ Node* makeNode(
+ Array& source,
+ int valuesPerNode,
+ int numMeanSplits,
+ Array& temp) {
+
+ Node* node = NULL;
+
+ if (source.size() <= valuesPerNode) {
+ // Make a new leaf node
+ node = new Node(source);
+
+ // Set the pointers in the memberTable
+ for (int i = 0; i < source.size(); ++i) {
+ memberTable.set(Member(source[i]), node);
+ }
+ source.clear();
+
+ } else {
+ // Make a new internal node
+ node = new Node();
+
+ const AABox& bounds = computeBounds(source, 0, source.size() - 1);
+ const Vector3& extent = bounds.high() - bounds.low();
+
+ Vector3::Axis splitAxis = extent.primaryAxis();
+
+ float splitLocation;
+
+ // Arrays for holding the children
+ Array lt, gt;
+
+ if (numMeanSplits <= 0) {
+
+ source.medianPartition(lt, node->valueArray, gt, temp, CenterComparator(splitAxis));
+
+ // Choose the split location to be the center of whatever fell in the center
+ splitLocation = node->valueArray[0]->center[splitAxis];
+
+ // Some of the elements in the lt or gt array might really overlap the split location.
+ // Move them as needed.
+ for (int i = 0; i < lt.size(); ++i) {
+ const AABox& bounds = lt[i]->bounds;
+ if ((bounds.low()[splitAxis] <= splitLocation) && (bounds.high()[splitAxis] >= splitLocation)) {
+ node->valueArray.append(lt[i]);
+ // Remove this element and process the new one that
+ // is swapped in in its place.
+ lt.fastRemove(i); --i;
+ }
+ }
+
+ for (int i = 0; i < gt.size(); ++i) {
+ const AABox& bounds = gt[i]->bounds;
+ if ((bounds.low()[splitAxis] <= splitLocation) && (bounds.high()[splitAxis] >= splitLocation)) {
+ node->valueArray.append(gt[i]);
+ // Remove this element and process the new one that
+ // is swapped in in its place.
+ gt.fastRemove(i); --i;
+ }
+ }
+
+ if ((node->valueArray.size() > (source.size() / 2)) &&
+ (source.size() > 6)) {
+ // This was a bad partition; we ended up putting the splitting plane right in the middle of most of the
+ // objects. We could try to split on a different axis, or use a different partition (e.g., the extents mean,
+ // or geometric mean). This implementation falls back on the extents mean, since that case is already handled
+ // below.
+ numMeanSplits = 1;
+ }
+ }
+
+ // Note: numMeanSplits may have been increased by the code in the previous case above in order to
+ // force a re-partition.
+
+ if (numMeanSplits > 0) {
+ // Split along the mean
+ splitLocation =
+ bounds.high()[splitAxis] * 0.5f +
+ bounds.low()[splitAxis] * 0.5f;
+
+ debugAssertM(isFinite(splitLocation),
+ "Internal error: split location must be finite.");
+
+ source.partition(NULL, lt, node->valueArray, gt, Comparator(splitAxis, splitLocation));
+
+ // The Comparator ensures that elements are strictly on the correct side of the split
+ }
+
+
+# if defined(G3D_DEBUG) && defined(VERIFY_TREE)
+ debugAssert(lt.size() + node->valueArray.size() + gt.size() == source.size());
+ // Verify that all objects ended up on the correct side of the split.
+ // (i.e., make sure that the Array partition was correct)
+ for (int i = 0; i < lt.size(); ++i) {
+ const AABox& bounds = lt[i]->bounds;
+ debugAssert(bounds.high()[splitAxis] < splitLocation);
+ }
+
+ for (int i = 0; i < gt.size(); ++i) {
+ const AABox& bounds = gt[i]->bounds;
+ debugAssert(bounds.low()[splitAxis] > splitLocation);
+ }
+
+ for (int i = 0; i < node->valueArray.size(); ++i) {
+ const AABox& bounds = node->valueArray[i]->bounds;
+ debugAssert(bounds.high()[splitAxis] >= splitLocation);
+ debugAssert(bounds.low()[splitAxis] <= splitLocation);
+ }
+# endif
+
+ // The source array is no longer needed
+ source.clear();
+
+ node->splitAxis = splitAxis;
+ node->splitLocation = splitLocation;
+
+ // Update the bounds array and member table
+ node->boundsArray.resize(node->valueArray.size());
+ for (int i = 0; i < node->valueArray.size(); ++i) {
+ Handle* v = node->valueArray[i];
+ node->boundsArray[i] = v->bounds;
+ memberTable.set(Member(v), node);
+ }
+
+ if (lt.size() > 0) {
+ node->child[0] = makeNode(lt, valuesPerNode, numMeanSplits - 1, temp);
+ }
+
+ if (gt.size() > 0) {
+ node->child[1] = makeNode(gt, valuesPerNode, numMeanSplits - 1, temp);
+ }
+
+ }
+
+ return node;
+ }
+
+ /**
+ Recursively clone the passed in node tree, setting
+ pointers for members in the memberTable as appropriate.
+ called by the assignment operator.
+ */
+ Node* cloneTree(Node* src) {
+ Node* dst = new Node(*src);
+
+ // Make back pointers
+ for (int i = 0; i < dst->valueArray.size(); ++i) {
+ memberTable.set(Member(dst->valueArray[i]), dst);
+ }
+
+ // Clone children
+ for (int i = 0; i < 2; ++i) {
+ if (src->child[i] != NULL) {
+ dst->child[i] = cloneTree(src->child[i]);
+ }
+ }
+
+ return dst;
+ }
+
+ /**
+ Wrapper for a Handle; used to create a memberTable that acts like Table but
+ stores only Handle* internally to avoid memory copies.
+ */
+ typedef _internal::Indirector Member;
+
+ typedef Table MemberTable;
+
+ /** Maps members to the node containing them */
+ MemberTable memberTable;
+
+ Node* root;
+
+public:
+
+ /** To construct a balanced tree, insert the elements and then call
+ KDTree::balance(). */
+ KDTree() : root(NULL) {}
+
+
+ KDTree(const KDTree& src) : root(NULL) {
+ *this = src;
+ }
+
+
+ KDTree& operator=(const KDTree& src) {
+ delete root;
+ // Clone tree takes care of filling out the memberTable.
+ root = cloneTree(src.root);
+ return *this;
+ }
+
+
+ ~KDTree() {
+ clear();
+ }
+
+ /**
+ Throws out all elements of the set.
+ */
+ void clear() {
+ typedef typename Table<_internal::Indirector, Node*>::Iterator It;
+
+ // Delete all handles stored in the member table
+ It cur = memberTable.begin();
+ It end = memberTable.end();
+ while (cur != end) {
+ delete cur->key.handle;
+ cur->key.handle = NULL;
+ ++cur;
+ }
+ memberTable.clear();
+
+ // Delete the tree structure itself
+ delete root;
+ root = NULL;
+ }
+
+ int size() const {
+ return memberTable.size();
+ }
+
+ /**
+ Inserts an object into the set if it is not
+ already present. O(log n) time. Does not
+ cause the tree to be balanced.
+ */
+ void insert(const T& value) {
+ if (contains(value)) {
+ // Already in the set
+ return;
+ }
+
+ Handle* h = new Handle(value);
+
+ if (root == NULL) {
+ // This is the first node; create a root node
+ root = new Node();
+ }
+
+ Node* node = root->findDeepestContainingNode(h->bounds);
+
+ // Insert into the node
+ node->valueArray.append(h);
+ node->boundsArray.append(h->bounds);
+
+ // Insert into the node table
+ Member m(h);
+ memberTable.set(m, node);
+ }
+
+ /** Inserts each elements in the array in turn. If the tree
+ begins empty (no structure and no elements), this is faster
+ than inserting each element in turn. You still need to balance
+ the tree at the end.*/
+ void insert(const Array& valueArray) {
+ if (root == NULL) {
+ // Optimized case for an empty tree; don't bother
+ // searching or reallocating the root node's valueArray
+ // as we incrementally insert.
+ root = new Node();
+ root->valueArray.resize(valueArray.size());
+ root->boundsArray.resize(root->valueArray.size());
+ for (int i = 0; i < valueArray.size(); ++i) {
+ // Insert in opposite order so that we have the exact same
+ // data structure as if we inserted each (i.e., order is reversed
+ // from array).
+ Handle* h = new Handle(valueArray[i]);
+ int j = valueArray.size() - i - 1;
+ root->valueArray[j] = h;
+ root->boundsArray[j] = h->bounds;
+ memberTable.set(Member(h), root);
+ }
+
+ } else {
+ // Insert at appropriate tree depth.
+ for (int i = 0; i < valueArray.size(); ++i) {
+ insert(valueArray[i]);
+ }
+ }
+ }
+
+
+ /**
+ Returns true if this object is in the set, otherwise
+ returns false. O(1) time.
+ */
+ bool contains(const T& value) {
+ // Temporarily create a handle and member
+ Handle h(value);
+ return memberTable.containsKey(Member(&h));
+ }
+
+
+ /**
+ Removes an object from the set in O(1) time.
+ It is an error to remove members that are not already
+ present. May unbalance the tree.
+
+ Removing an element never causes a node (split plane) to be removed...
+ nodes are only changed when the tree is rebalanced. This behavior
+ is desirable because it allows the split planes to be serialized,
+ and then deserialized into an empty tree which can be repopulated.
+ */
+ void remove(const T& value) {
+ debugAssertM(contains(value),
+ "Tried to remove an element from a "
+ "KDTree that was not present");
+
+ // Get the list of elements at the node
+ Handle h(value);
+ Member m(&h);
+
+ Array& list = memberTable[m]->valueArray;
+
+ Handle* ptr = NULL;
+
+ // Find the element and remove it
+ for (int i = list.length() - 1; i >= 0; --i) {
+ if (list[i]->value == value) {
+ // This was the element. Grab the pointer so that
+ // we can delete it below
+ ptr = list[i];
+
+ // Remove the handle from the node
+ list.fastRemove(i);
+
+ // Remove the corresponding bounds
+ memberTable[m]->boundsArray.fastRemove(i);
+ break;
+ }
+ }
+
+ // Remove the member
+ memberTable.remove(m);
+
+ // Delete the handle data structure
+ delete ptr;
+ ptr = NULL;
+ }
+
+
+ /**
+ If the element is in the set, it is removed.
+ The element is then inserted.
+
+ This is useful when the == and hashCode methods
+ on T are independent of the bounds. In
+ that case, you may call update(v) to insert an
+ element for the first time and call update(v)
+ again every time it moves to keep the tree
+ up to date.
+ */
+ void update(const T& value) {
+ if (contains(value)) {
+ remove(value);
+ }
+ insert(value);
+ }
+
+
+ /**
+ Rebalances the tree (slow). Call when objects
+ have moved substantially from their original positions
+ (which unbalances the tree and causes the spatial
+ queries to be slow).
+
+ @param valuesPerNode Maximum number of elements to put at
+ a node.
+
+ @param numMeanSplits numMeanSplits = 0 gives a
+ fully axis aligned BSP-tree, where the balance operation attempts to balance
+ the tree so that every splitting plane has an equal number of left
+ and right children (i.e. it is a median split along that axis).
+ This tends to maximize average performance.
+
+ You can override this behavior by
+ setting a number of mean (average) splits. numMeanSplits = MAX_INT
+ creates a full oct-tree, which tends to optimize peak performance at the expense of
+ average performance. It tends to have better clustering behavior when
+ members are not uniformly distributed.
+ */
+ void balance(int valuesPerNode = 5, int numMeanSplits = 3) {
+ if (root == NULL) {
+ // Tree is empty
+ return;
+ }
+
+ // Get all handles and delete the old tree structure
+ Node* oldRoot = root;
+ for (int c = 0; c < 2; ++c) {
+ if (root->child[c] != NULL) {
+ root->child[c]->getHandles(root->valueArray);
+
+ // Delete the child; this will delete all structure below it
+ delete root->child[c];
+ root->child[c] = NULL;
+ }
+ }
+
+ Array temp;
+ // Make a new root. Work with a copy of the value array because
+ // makeNode clears the source array as it progresses
+ Array copy(oldRoot->valueArray);
+ root = makeNode(copy, valuesPerNode, numMeanSplits, temp);
+
+ // Throw away the old root node
+ delete oldRoot;
+ oldRoot = NULL;
+
+ // Walk the tree, assigning splitBounds. We start with unbounded
+ // space. This will override the current member table.
+ const AABox& LARGE = AABox::large();
+ root->assignSplitBounds(LARGE);
+
+# ifdef _DEBUG
+ {
+ // Ensure that the balanced tree is still correct
+ root->verifyNode(LARGE.low(), LARGE.high());
+ }
+# endif
+ }
+
+
+ /** Clear, set the contents to the values in the array, and then balance */
+ void setContents(const Array& array, int valuesPerNode = 5, int numMeanSplits = 3) {
+ clear();
+ insert(array);
+ balance(valuesPerNode, numMeanSplits);
+ }
+
+
+protected:
+
+ /**
+ @param parentMask The mask that this node returned from culledBy.
+ */
+ static void getIntersectingMembers(
+ const Array& plane,
+ Array& members,
+ Node* node,
+ uint32 parentMask) {
+
+ int dummy;
+
+ if (parentMask == 0) {
+ // None of these planes can cull anything
+ for (int v = node->valueArray.size() - 1; v >= 0; --v) {
+ members.append(& (node->valueArray[v]->value));
+ }
+
+ // Iterate through child nodes
+ for (int c = 0; c < 2; ++c) {
+ if (node->child[c]) {
+ getIntersectingMembers(plane, members, node->child[c], 0);
+ }
+ }
+ } else {
+
+ // Test values at this node against remaining planes
+ for (int v = node->boundsArray.size() - 1; v >= 0; --v) {
+ if (! node->boundsArray[v].culledBy(plane, dummy, parentMask)) {
+ members.append(&(node->valueArray[v]->value));
+ }
+ }
+
+ uint32 childMask = 0xFFFFFF;
+
+ // Iterate through child nodes
+ for (int c = 0; c < 2; ++c) {
+ if (node->child[c] &&
+ ! node->child[c]->splitBounds.culledBy(plane, dummy, parentMask, childMask)) {
+ // This node was not culled
+ getIntersectingMembers(plane, members, node->child[c], childMask);
+ }
+ }
+ }
+ }
+
+public:
+
+ /**
+ Returns all members inside the set of planes.
+ @param members The results are appended to this array.
+ */
+ void getIntersectingMembers(const Array& plane, Array& members) const {
+ if (root == NULL) {
+ return;
+ }
+
+ getIntersectingMembers(plane, members, root, 0xFFFFFF);
+ }
+
+ void getIntersectingMembers(const Array& plane, Array& members) const {
+ Array temp;
+ getIntersectingMembers(plane, temp, root, 0xFFFFFF);
+ for (int i = 0; i < temp.size(); ++i) {
+ members.append(*temp[i]);
+ }
+ }
+
+ /**
+ Typically used to find all visible
+ objects inside the view frustum (see also GCamera::getClipPlanes)... i.e. all objects
+ not culled by frustum.
+
+ Example:
+
+ Array visible;
+ tree.getIntersectingMembers(camera.frustum(), visible);
+ // ... Draw all objects in the visible array.
+
+ @param members The results are appended to this array.
+ */
+ void getIntersectingMembers(const GCamera::Frustum& frustum, Array& members) const {
+ Array plane;
+
+ for (int i = 0; i < frustum.faceArray.size(); ++i) {
+ plane.append(frustum.faceArray[i].plane);
+ }
+
+ getIntersectingMembers(plane, members);
+ }
+
+ void getIntersectingMembers(const GCamera::Frustum& frustum, Array& members) const {
+ Array temp;
+ getIntersectingMembers(frustum, temp);
+ for (int i = 0; i < temp.size(); ++i) {
+ members.append(*temp[i]);
+ }
+ }
+
+ /**
+ C++ STL style iterator variable. See beginBoxIntersection().
+ The iterator overloads the -> (dereference) operator, so this
+ acts like a pointer to the current member.
+ */
+ // This iterator turns Node::getIntersectingMembers into a
+ // coroutine. It first translates that method from recursive to
+ // stack based, then captures the system state (analogous to a Scheme
+ // continuation) after each element is appended to the member array,
+ // and allowing the computation to be restarted.
+ class BoxIntersectionIterator {
+ private:
+ friend class TreeType;
+
+ /** True if this is the "end" iterator instance */
+ bool isEnd;
+
+ /** The box that we're testing against. */
+ AABox box;
+
+ /** Node that we're currently looking at. Undefined if isEnd
+ is true. */
+ Node* node;
+
+ /** Nodes waiting to be processed */
+ // We could use backpointers within the tree and careful
+ // state management to avoid ever storing the stack-- but
+ // it is much easier this way and only inefficient if the
+ // caller uses post increment (which they shouldn't!).
+ Array stack;
+
+ /** The next index of current->valueArray to return.
+ Undefined when isEnd is true.*/
+ int nextValueArrayIndex;
+
+ BoxIntersectionIterator() : isEnd(true) {}
+
+ BoxIntersectionIterator(const AABox& b, const Node* root) :
+ isEnd(root == NULL), box(b),
+ node(const_cast(root)), nextValueArrayIndex(-1) {
+
+ // We intentionally start at the "-1" index of the current
+ // node so we can use the preincrement operator to move
+ // ourselves to element 0 instead of repeating all of the
+ // code from the preincrement method. Note that this might
+ // cause us to become the "end" instance.
+ ++(*this);
+ }
+
+ public:
+
+ inline bool operator!=(const BoxIntersectionIterator& other) const {
+ return ! (*this == other);
+ }
+
+ bool operator==(const BoxIntersectionIterator& other) const {
+ if (isEnd) {
+ return other.isEnd;
+ } else if (other.isEnd) {
+ return false;
+ } else {
+ // Two non-end iterators; see if they match. This is kind of
+ // silly; users shouldn't call == on iterators in general unless
+ // one of them is the end iterator.
+ if ((box != other.box) || (node != other.node) ||
+ (nextValueArrayIndex != other.nextValueArrayIndex) ||
+ (stack.length() != other.stack.length())) {
+ return false;
+ }
+
+ // See if the stacks are the same
+ for (int i = 0; i < stack.length(); ++i) {
+ if (stack[i] != other.stack[i]) {
+ return false;
+ }
+ }
+
+ // We failed to find a difference; they must be the same
+ return true;
+ }
+ }
+
+ /**
+ Pre increment.
+ */
+ BoxIntersectionIterator& operator++() {
+ ++nextValueArrayIndex;
+
+ bool foundIntersection = false;
+ while (! isEnd && ! foundIntersection) {
+
+ // Search for the next node if we've exhausted this one
+ while ((! isEnd) && (nextValueArrayIndex >= node->valueArray.length())) {
+ // If we entered this loop, then the iterator has exhausted the elements at
+ // node (possibly because it just switched to a child node with no members).
+ // This loop continues until it finds a node with members or reaches
+ // the end of the whole intersection search.
+
+ // If the right child overlaps the box, push it onto the stack for
+ // processing.
+ if ((node->child[1] != NULL) &&
+ (box.high()[node->splitAxis] > node->splitLocation)) {
+ stack.push(node->child[1]);
+ }
+
+ // If the left child overlaps the box, push it onto the stack for
+ // processing.
+ if ((node->child[0] != NULL) &&
+ (box.low()[node->splitAxis] < node->splitLocation)) {
+ stack.push(node->child[0]);
+ }
+
+ if (stack.length() > 0) {
+ // Go on to the next node (which may be either one of the ones we
+ // just pushed, or one from farther back the tree).
+ node = stack.pop();
+ nextValueArrayIndex = 0;
+ } else {
+ // That was the last node; we're done iterating
+ isEnd = true;
+ }
+ }
+
+ // Search for the next intersection at this node until we run out of children
+ while (! isEnd && ! foundIntersection && (nextValueArrayIndex < node->valueArray.length())) {
+ if (box.intersects(node->boundsArray[nextValueArrayIndex])) {
+ foundIntersection = true;
+ } else {
+ ++nextValueArrayIndex;
+ // If we exhaust this node, we'll loop around the master loop
+ // to find a new node.
+ }
+ }
+ }
+
+ return *this;
+ }
+
+ private:
+ /**
+ Post increment (much slower than preincrement!).
+ Intentionally overloaded to preclude accidentally slow code.
+ */
+ BoxIntersectionIterator operator++(int);
+ /*{
+ BoxIntersectionIterator old = *this;
+ ++this;
+ return old;
+ }*/
+
+ public:
+
+ /** Overloaded dereference operator so the iterator can masquerade as a pointer
+ to a member */
+ const T& operator*() const {
+ alwaysAssertM(! isEnd, "Can't dereference the end element of an iterator");
+ return node->valueArray[nextValueArrayIndex]->value;
+ }
+
+ /** Overloaded dereference operator so the iterator can masquerade as a pointer
+ to a member */
+ T const * operator->() const {
+ alwaysAssertM(! isEnd, "Can't dereference the end element of an iterator");
+ return &(stack.last()->valueArray[nextValueArrayIndex]->value);
+ }
+
+ /** Overloaded cast operator so the iterator can masquerade as a pointer
+ to a member */
+ operator T*() const {
+ alwaysAssertM(! isEnd, "Can't dereference the end element of an iterator");
+ return &(stack.last()->valueArray[nextValueArrayIndex]->value);
+ }
+ };
+
+
+ /**
+ Iterates through the members that intersect the box
+ */
+ BoxIntersectionIterator beginBoxIntersection(const AABox& box) const {
+ return BoxIntersectionIterator(box, root);
+ }
+
+ BoxIntersectionIterator endBoxIntersection() const {
+ // The "end" iterator instance
+ return BoxIntersectionIterator();
+ }
+
+ /**
+ Appends all members whose bounds intersect the box.
+ See also KDTree::beginBoxIntersection.
+ */
+ void getIntersectingMembers(const AABox& box, Array& members) const {
+ if (root == NULL) {
+ return;
+ }
+ root->getIntersectingMembers(box, Sphere(Vector3::zero(), 0), members, false);
+ }
+
+ void getIntersectingMembers(const AABox& box, Array& members) const {
+ Array temp;
+ getIntersectingMembers(box, temp);
+ for (int i = 0; i < temp.size(); ++i) {
+ members.append(*temp[i]);
+ }
+ }
+
+
+ /**
+ Invoke a callback for every member along a ray until the closest intersection is found.
+
+ @param callback either a function or an instance of a class with an overloaded operator() of the form:
+
+ void callback(const Ray& ray, const T& object, float& distance). If the ray hits the object
+ before travelling distance distance, updates distance with the new distance to
+ the intersection, otherwise leaves it unmodified. A common example is:
+
+
+ class Entity {
+ public:
+
+ void intersect(const Ray& ray, float& maxDist, Vector3& outLocation, Vector3& outNormal) {
+ float d = maxDist;
+
+ // ... search for intersection distance d
+
+ if ((d > 0) && (d < maxDist)) {
+ // Intersection occured
+ maxDist = d;
+ outLocation = ...;
+ outNormal = ...;
+ }
+ }
+ };
+
+ // Finds the surface normal and location of the first intersection with the scene
+ class Intersection {
+ public:
+ Entity* closestEntity;
+ Vector3 hitLocation;
+ Vector3 hitNormal;
+
+ void operator()(const Ray& ray, const Entity* entity, float& distance) {
+ entity->intersect(ray, distance, hitLocation, hitNormal);
+ }
+ };
+
+ KDTree scene;
+
+ Intersection intersection;
+ float distance = finf();
+ scene.intersectRay(camera.worldRay(x, y), intersection, distance);
+
+
+
+ @param distance When the method is invoked, this is the maximum
+ distance that the tree should search for an intersection. On
+ return, this is set to the distance to the first intersection
+ encountered.
+
+ @param intersectCallbackIsFast If false, each object's bounds are
+ tested before the intersectCallback is invoked. If the
+ intersect callback runs at the same speed or faster than
+ AABox-ray intersection, set this to true.
+ */
+ template
+ void intersectRay(
+ const Ray& ray,
+ RayCallback& intersectCallback,
+ float& distance,
+ bool intersectCallbackIsFast = false) const {
+
+ root->intersectRay(ray, intersectCallback, distance, intersectCallbackIsFast);
+ }
+
+
+ /**
+ @brief Finds all members whose bounding boxes intersect the sphere. The actual
+ elements may not intersect the sphere.
+
+ @param members The results are appended to this array.
+ */
+ void getIntersectingMembers(const Sphere& sphere, Array& members) const {
+ if (root == NULL) {
+ return;
+ }
+
+ AABox box;
+ sphere.getBounds(box);
+ root->getIntersectingMembers(box, sphere, members, true);
+ }
+
+ void getIntersectingMembers(const Sphere& sphere, Array& members) const {
+ Array temp;
+ getIntersectingMembers(sphere, temp);
+ for (int i = 0; i < temp.size(); ++i) {
+ members.append(*temp[i]);
+ }
+ }
+
+ /**
+ Stores the locations of the splitting planes (the structure but not the content)
+ so that the tree can be quickly rebuilt from a previous configuration without
+ calling balance.
+ */
+ void serializeStructure(BinaryOutput& bo) const {
+ Node::serializeStructure(root, bo);
+ }
+
+ /** Clears the member table */
+ void deserializeStructure(BinaryInput& bi) {
+ clear();
+ root = Node::deserializeStructure(bi);
+ }
+
+ /**
+ Returns an array of all members of the set. See also KDTree::begin.
+ */
+ void getMembers(Array& members) const {
+ Array temp;
+ memberTable.getKeys(temp);
+ for (int i = 0; i < temp.size(); ++i) {
+ members.append(*(temp.handle));
+ }
+ }
+
+
+ /** If a value that is EqualsFunc to @a value is present, returns a pointer to the
+ version stored in the data structure, otherwise returns NULL.
+ */
+ const T* getPointer(const T& value) const {
+ // Temporarily create a handle and member
+ Handle h(value);
+ const Member* member = memberTable.getKeyPointer(Member(&h));
+ if (member == NULL) {
+ // Not found
+ return NULL;
+ } else {
+ return &(member->handle->value);
+ }
+ }
+
+
+ /**
+ C++ STL style iterator variable. See begin().
+ Overloads the -> (dereference) operator, so this acts like a pointer
+ to the current member.
+ */
+ class Iterator {
+ private:
+ friend class TreeType;
+
+ // Note: this is a Table iterator, we are currently defining
+ // Set iterator
+ typename Table::Iterator it;
+
+ Iterator(const typename Table::Iterator& it) : it(it) {}
+
+ public:
+
+ inline bool operator!=(const Iterator& other) const {
+ return !(*this == other);
+ }
+
+ bool operator==(const Iterator& other) const {
+ return it == other.it;
+ }
+
+ /**
+ Pre increment.
+ */
+ Iterator& operator++() {
+ ++it;
+ return *this;
+ }
+
+ private:
+ /**
+ Post increment (slower than preincrement). Intentionally unimplemented to prevent slow code.
+ */
+ Iterator operator++(int);/* {
+ Iterator old = *this;
+ ++(*this);
+ return old;
+ }*/
+ public:
+
+ const T& operator*() const {
+ return it->key.handle->value;
+ }
+
+ T* operator->() const {
+ return &(it->key.handle->value);
+ }
+
+ operator T*() const {
+ return &(it->key.handle->value);
+ }
+ };
+
+
+ /**
+ C++ STL style iterator method. Returns the first member.
+ Use preincrement (++entry) to get to the next element (iteration
+ order is arbitrary).
+ Do not modify the set while iterating.
+ */
+ Iterator begin() const {
+ return Iterator(memberTable.begin());
+ }
+
+
+ /**
+ C++ STL style iterator method. Returns one after the last iterator
+ element.
+ */
+ Iterator end() const {
+ return Iterator(memberTable.end());
+ }
+#undef TreeType
+};
+
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Line.h b/dep/include/g3dlite/G3D/Line.h
index 5dd82c19b..3579a6bec 100644
--- a/dep/include/g3dlite/G3D/Line.h
+++ b/dep/include/g3dlite/G3D/Line.h
@@ -3,7 +3,7 @@
Line class
- @maintainer Morgan McGuire, matrix@graphics3d.com
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
@created 2001-06-02
@edited 2006-02-28
@@ -38,6 +38,12 @@ public:
/** Undefined (provided for creating Array only) */
inline Line() {}
+ Line(class BinaryInput& b);
+
+ void serialize(class BinaryOutput& b) const;
+
+ void deserialize(class BinaryInput& b);
+
virtual ~Line() {}
/**
@@ -77,6 +83,20 @@ public:
is no intersection, returns a point at infinity.
*/
Vector3 intersection(const Plane &plane) const;
+
+
+ /** Finds the closest point to the two lines.
+
+ @param minDist Returns the minimum distance between the lines.
+
+ @cite http://objectmix.com/graphics/133793-coordinates-closest-points-pair-skew-lines.html
+ */
+ Vector3 closestPoint(const Line& B, float& minDist) const;
+
+ inline Vector3 closestPoint(const Line& B) const {
+ float m;
+ return closestPoint(B, m);
+ }
};
};// namespace
diff --git a/dep/include/g3dlite/G3D/LineSegment.h b/dep/include/g3dlite/G3D/LineSegment.h
new file mode 100644
index 000000000..70210ec7e
--- /dev/null
+++ b/dep/include/g3dlite/G3D/LineSegment.h
@@ -0,0 +1,115 @@
+/**
+ @file LineSegment.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-02-08
+ @edited 2008-02-02
+ */
+
+#ifndef G3D_LINESEGMENT_H
+#define G3D_LINESEGMENT_H
+
+#include "G3D/platform.h"
+#include "G3D/Vector3.h"
+
+namespace G3D {
+
+/**
+ An finite segment of an infinite 3D line.
+ */
+class LineSegment {
+protected:
+
+ Vector3 _point;
+
+ /** Not normalized */
+ Vector3 direction;
+
+ LineSegment(const Vector3& __point, const Vector3& _direction) : _point(__point), direction(_direction) {
+ }
+
+public:
+
+ inline LineSegment() : _point(Vector3::zero()), direction(Vector3::zero()) {}
+
+ LineSegment(class BinaryInput& b);
+
+ void serialize(class BinaryOutput& b) const;
+
+ void deserialize(class BinaryInput& b);
+
+ virtual ~LineSegment() {}
+
+ /**
+ * Constructs a line from two (not equal) points.
+ */
+ static LineSegment fromTwoPoints(const Vector3 &point1, const Vector3 &point2) {
+ return LineSegment(point1, point2 - point1);
+ }
+
+ /** Call with 0 or 1 */
+ Vector3 point(int i) const;
+
+ inline float length() const {
+ return direction.magnitude();
+ }
+
+ /**
+ * Returns the closest point on the line segment to point.
+ */
+ Vector3 closestPoint(const Vector3 &point) const;
+
+ /**
+ Returns the distance between point and the line
+ */
+ double distance(const Vector3& p) const {
+ return (closestPoint(p) - p).magnitude();
+ }
+
+ double distanceSquared(const Vector3& p) const {
+ return (closestPoint(p) - p).squaredMagnitude();
+ }
+
+ /** Returns true if some part of this segment is inside the sphere */
+ bool intersectsSolidSphere(const class Sphere& s) const;
+
+ Vector3 randomPoint() const;
+
+};
+
+
+class LineSegment2D {
+private:
+
+ Vector2 m_origin;
+
+ /** Not normalized */
+ Vector2 m_direction;
+
+ /** Length of m_direction */
+ float m_length;
+
+public:
+
+ LineSegment2D() {}
+
+ static LineSegment2D fromTwoPoints(const Vector2& p0, const Vector2& p1);
+
+ /** Returns the intersection of these segements (including
+ testing endpoints), or Vector2::inf() if they do not intersect. */
+ Vector2 intersection(const LineSegment2D& other) const;
+
+ Vector2 point(int i) const;
+
+ Vector2 closestPoint(const Vector2& Q) const;
+
+ float distance(const Vector2& p) const;
+
+ float length() const;
+};
+
+} // namespace
+
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Log.h b/dep/include/g3dlite/G3D/Log.h
new file mode 100644
index 000000000..d252d0c1a
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Log.h
@@ -0,0 +1,109 @@
+/**
+ @file Log.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @cite Backtrace by Aaron Orenstein
+ @created 2001-08-04
+ @edited 2005-11-04
+ */
+
+#ifndef G3D_LOG_H
+#define G3D_LOG_H
+
+#include
+#include
+#include "G3D/platform.h"
+
+#ifndef G3D_WIN32
+ #include
+#endif
+
+namespace G3D {
+
+/** Prints to the common system log, log.txt, which is usually
+ in the working directory of the program. If your disk is
+ not writable or is slow, it will attempt to write to "c:/tmp/log.txt" or
+ "c:/temp/log.txt" on Windows systems instead.
+
+ Unlike printf or debugPrintf,
+ this function guarantees that all output is committed before it returns.
+ This is very useful for debugging a crash, which might hide the last few
+ buffered print statements otherwise.
+
+ Many G3D routines write useful warnings and debugging information to the
+ system log, which makes it a good first place to go when tracking down
+ a problem.
+ */
+void logPrintf(const char* fmt, ...);
+
+/** Does not flush the buffer; follow up with a logPrintf to force the flush. */
+void logLazyPrintf(const char* fmt, ...);
+
+/**
+ System log for debugging purposes. The first log opened
+ is the "common log" and can be accessed with the static
+ method common(). If you access common() and a common log
+ does not yet exist, one is created for you.
+ */
+class Log {
+private:
+
+ /**
+ Log messages go here.
+ */
+ FILE* logFile;
+
+ std::string filename;
+
+ static Log* commonLog;
+
+ int stripFromStackBottom;
+
+public:
+
+ /**
+ @param stripFromStackBottom Number of call stacks to strip from the
+ bottom of the stack when printing a trace. Useful for hiding
+ routines like "main" and "WinMain". If the specified file cannot
+ be opened for some reason, tries to open "c:/tmp/log.txt" or
+ "c:/temp/log.txt" instead.
+ */
+ Log(const std::string& filename = "log.txt",
+ int stripFromStackBottom = 0);
+
+ virtual ~Log();
+
+ /**
+ Returns the handle to the file log.
+ */
+ FILE* getFile() const;
+
+ /**
+ Marks the beginning of a logfile section.
+ */
+ void section(const std::string& s);
+
+ /**
+ Given arguments like printf, writes characters to the debug text overlay.
+ */
+ // We want G3D_CHECK_PRINTF_ARGS here, but that conflicts with the
+ // overload.
+ void __cdecl printf(const char* fmt, ...) G3D_CHECK_PRINTF_METHOD_ARGS;
+
+ void __cdecl vprintf(const char*, va_list argPtr) G3D_CHECK_VPRINTF_METHOD_ARGS;
+ /** Does not flush */
+ void __cdecl lazyvprintf(const char*, va_list argPtr) G3D_CHECK_VPRINTF_METHOD_ARGS;
+
+ static Log* common();
+
+ static std::string getCommonLogFilename();
+
+ void print(const std::string& s);
+
+
+ void println(const std::string& s);
+};
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Map2D.h b/dep/include/g3dlite/G3D/Map2D.h
new file mode 100644
index 000000000..9af9f7242
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Map2D.h
@@ -0,0 +1,667 @@
+/**
+ @file Map2D.h
+
+ More flexible support than provided by G3D::GImage.
+
+ @maintainer Morgan McGuire, morgan@cs.brown.edu
+ @created 2004-10-10
+ @edited 2009-03-24
+ */
+#ifndef G3D_Map2D_h
+#define G3D_Map2D_h
+
+#include "G3D/platform.h"
+#include "G3D/g3dmath.h"
+#include "G3D/Array.h"
+#include "G3D/vectorMath.h"
+#include "G3D/Vector2int16.h"
+#include "G3D/ReferenceCount.h"
+#include "G3D/AtomicInt32.h"
+#include "G3D/GThread.h"
+#include "G3D/Rect2D.h"
+#include "G3D/WrapMode.h"
+
+#include
+
+namespace G3D {
+namespace _internal {
+
+/** The default compute type for a type is the type itself. */
+template class _GetComputeType {
+public:
+ typedef Storage Type;
+};
+
+} // _internal
+} // G3D
+
+// This weird syntax is needed to support VC6, which doesn't
+// properly implement template overloading.
+#define DECLARE_COMPUTE_TYPE(StorageType, ComputeType) \
+namespace G3D { \
+ namespace _internal { \
+ template<> class _GetComputeType < StorageType > { \
+ public: \
+ typedef ComputeType Type; \
+ }; \
+ } \
+}
+
+DECLARE_COMPUTE_TYPE( float32, float64)
+DECLARE_COMPUTE_TYPE( float64, float64)
+
+DECLARE_COMPUTE_TYPE( int8, float32)
+DECLARE_COMPUTE_TYPE( int16, float32)
+DECLARE_COMPUTE_TYPE( int32, float64)
+DECLARE_COMPUTE_TYPE( int64, float64)
+
+DECLARE_COMPUTE_TYPE( uint8, float32)
+DECLARE_COMPUTE_TYPE( uint16, float32)
+DECLARE_COMPUTE_TYPE( uint32, float64)
+DECLARE_COMPUTE_TYPE( uint64, float64)
+
+DECLARE_COMPUTE_TYPE( Vector2, Vector2)
+DECLARE_COMPUTE_TYPE( Vector2int16, Vector2)
+
+DECLARE_COMPUTE_TYPE( Vector3, Vector3)
+DECLARE_COMPUTE_TYPE( Vector3int16, Vector3)
+
+DECLARE_COMPUTE_TYPE( Vector4, Vector4)
+
+DECLARE_COMPUTE_TYPE( Color3, Color3)
+DECLARE_COMPUTE_TYPE( Color3uint8, Color3)
+
+DECLARE_COMPUTE_TYPE( Color4, Color4)
+DECLARE_COMPUTE_TYPE( Color4uint8, Color4)
+#undef DECLARE_COMPUTE_TYPE
+
+namespace G3D {
+
+/**
+ Map of values across a discrete 2D plane. Can be thought of as a generic class for 2D images,
+ allowing flexibility as to pixel format and convenient methods.
+ In fact, the "pixels" can be any values
+ on a grid that can be sensibly interpolated--RGB colors, scalars, 4D vectors, and so on.
+
+ Other "image" classes in G3D:
+
+ G3D::GImage - Supports file formats, fast, Color3uint8 and Color4uint8 formats. No interpolation.
+
+ G3D::Texture::Ref - Represents image on the graphics card (not directly readable on the CPU). Supports 2D, 3D, and a variety of interpolation methods, loads file formats.
+
+ G3D::Image3 - A subclass of Map2D that supports image loading and saving and conversion to Texture.
+
+ G3D::Image4 - A subclass of Map2D that supports image loading and saving and conversion to Texture.
+
+ G3D::Image3uint8 - A subclass of Map2D that supports image loading and saving and conversion to Texture.
+
+ G3D::Image4uint8 - A subclass of Map2D that supports image loading and saving and conversion to Texture.
+
+ There are two type parameters-- the first (@ Storage) is the type
+ used to store the "pixel" values efficiently and
+ the second (@a Compute) is
+ the type operated on by computation. The Compute::Compute(Storage&) constructor
+ is used to convert between storage and computation types.
+ @a Storage is often an integer version of @a Compute, for example
+ Map2D. By default, the computation type is:
+
+
+ Storage Computation
+
+ uint8 float32
+ uint16 float32
+ uint32 float64
+ uint64 float64
+
+ int8 float32
+ int16 float32
+ int32 float64
+ int64 float64
+
+ float32 float64
+ float64 float64
+
+ Vector2 Vector2
+ Vector2int16 Vector2
+
+ Vector3 Vector3
+ Vector3int16 Vector3
+
+ Vector4 Vector4
+
+ Color3 Color3
+ Color3uint8 Color3
+
+ Color4 Color4
+ Color4uint8 Color4
+
+ Any other storage type defaults to itself as the computation type.
+
+ The computation type can be any that
+ supports lerp, +, -, *, /, and an empty constructor.
+
+ Assign value:
+
+ im->set(x, y, 7); or
+ im->get(x, y) = 7;
+
+ Read value:
+
+ int c = im(x, y);
+
+ Can also sample with nearest neighbor, bilinear, and bicubic
+ interpolation.
+
+ Sampling follows OpenGL conventions, where
+ pixel values represent grid points and (0.5, 0.5) is half-way
+ between two vertical and two horizontal grid points.
+ To draw an image of dimensions w x h with nearest neighbor
+ sampling, render pixels from [0, 0] to [w - 1, h - 1].
+
+ Under the WrapMode::CLAMP wrap mode, the value of bilinear interpolation
+ becomes constant outside [1, w - 2] horizontally. Nearest neighbor
+ interpolation is constant outside [0, w - 1] and bicubic outside
+ [3, w - 4]. The class does not offer quadratic interpolation because
+ the interpolation filter could not center over a pixel.
+
+ @author Morgan McGuire, http://graphics.cs.williams.edu
+ */
+template< typename Storage,
+typename Compute = typename G3D::_internal::_GetComputeType::Type>
+class Map2D : public ReferenceCountedObject {
+
+//
+// It doesn't make sense to automatically convert from Compute back to Storage
+// because the rounding rule (and scaling) is application dependent.
+// Thus the interpolation methods all return type Compute.
+//
+
+public:
+
+ typedef Storage StorageType;
+ typedef Compute ComputeType;
+ typedef Map2D Type;
+ typedef ReferenceCountedPointer Ref;
+
+protected:
+
+ Storage ZERO;
+
+ /** Width, in pixels. */
+ uint32 w;
+
+ /** Height, in pixels. */
+ uint32 h;
+
+ WrapMode _wrapMode;
+
+ /** 0 if no mutating method has been invoked
+ since the last call to setChanged(); */
+ AtomicInt32 m_changed;
+
+ Array data;
+
+ /** Handles the exceptional cases from get */
+ const Storage& slowGet(int x, int y, WrapMode wrap) {
+ switch (wrap) {
+ case WrapMode::CLAMP:
+ return fastGet(iClamp(x, 0, w - 1), iClamp(y, 0, h - 1));
+
+ case WrapMode::TILE:
+ return fastGet(iWrap(x, w), iWrap(y, h));
+
+ case WrapMode::ZERO:
+ return ZERO;
+
+ case WrapMode::ERROR:
+ alwaysAssertM(((uint32)x < w) && ((uint32)y < h),
+ format("Index out of bounds: (%d, %d), w = %d, h = %d",
+ x, y, w, h));
+
+ // intentionally fall through
+ case WrapMode::IGNORE:
+ // intentionally fall through
+ default:
+ {
+ static Storage temp;
+ return temp;
+ }
+ }
+ }
+
+public:
+
+ /** Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds. */
+ inline const Storage& fastGet(int x, int y) const {
+ debugAssert(((uint32)x < w) && ((uint32)y < h));
+ return data[x + y * w];
+ }
+
+ /** Unsafe access to the underlying data structure with no wrapping support; requires that (x, y) is in bounds. */
+ inline void fastSet(int x, int y, const Storage& v) {
+ debugAssert(((uint32)x < w) && ((uint32)y < h));
+ data[x + y * w] = v;
+ }
+
+protected:
+
+ /** Given four control points and a value on the range [0, 1)
+ evaluates the Catmull-rom spline between the times of the
+ middle two control points */
+ Compute bicubic(const Compute* ctrl, double s) const {
+
+ // f = B * S * ctrl'
+
+ // B matrix: Catmull-Rom spline basis
+ static const double B[4][4] = {
+ { 0.0, -0.5, 1.0, -0.5},
+ { 1.0, 0.0, -2.5, 1.5},
+ { 0.0, 0.5, 2.0, -1.5},
+ { 0.0, 0.0, -0.5, 0.5}};
+
+ // S: Powers of the fraction
+ double S[4];
+ double s2 = s * s;
+ S[0] = 1.0;
+ S[1] = s;
+ S[2] = s2;
+ S[3] = s2 * s;
+
+ Compute sum(ZERO);
+
+ for (int c = 0; c < 4; ++c) {
+ double coeff = 0.0;
+ for (int power = 0; power < 4; ++power) {
+ coeff += B[c][power] * S[power];
+ }
+ sum += ctrl[c] * coeff;
+ }
+
+ return sum;
+ }
+
+
+ Map2D(int w, int h, WrapMode wrap) : w(0), h(0), _wrapMode(wrap), m_changed(1) {
+ ZERO = Storage(Compute(Storage()) * 0);
+ resize(w, h);
+ }
+
+public:
+
+ /**
+ Although Map2D is not threadsafe (except for the setChanged() method),
+ you can use this mutex to create your own threadsafe access to a Map2D.
+ Not used by the default implementation.
+ */
+ GMutex mutex;
+
+ static Ref create(int w = 0, int h = 0, WrapMode wrap = WrapMode::ERROR) {
+ return new Map2D(w, h, wrap);
+ }
+
+ /** Resizes without clearing, leaving garbage.
+ */
+ void resize(uint32 newW, uint32 newH) {
+ if ((newW != w) || (newH != h)) {
+ w = newW;
+ h = newH;
+ data.resize(w * h);
+ setChanged(true);
+ }
+ }
+
+ /**
+ Returns true if this map has been written to since the last call to setChanged(false).
+ This is useful if you are caching a texture map other value that must be recomputed
+ whenever this changes.
+ */
+ bool changed() {
+ return m_changed.value() != 0;
+ }
+
+ /** Set/unset the changed flag. */
+ void setChanged(bool c) {
+ m_changed = c ? 1 : 0;
+ }
+
+ /** Returns a pointer to the underlying row-major data. There is no padding at the end of the row.
+ Be careful--this will be reallocated during a resize. You should call setChanged(true) if you mutate the array.*/
+ Storage* getCArray() {
+ return data.getCArray();
+ }
+
+
+ const Storage* getCArray() const {
+ return data.getCArray();
+ }
+
+
+ /** Row-major array. You should call setChanged(true) if you mutate the array. */
+ Array& getArray() {
+ return data;
+ }
+
+
+ const Array& getArray() const {
+ return data;
+ }
+
+ /** is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode */
+ inline bool inBounds(int x, int y) const {
+ return (((uint32)x < w) && ((uint32)y < h));
+ }
+
+ /** is (x, y) strictly within the image bounds, or will it trigger some kind of wrap mode */
+ inline bool inBounds(const Vector2int16& v) const {
+ return inBounds(v.x, v.y);
+ }
+
+ /** Get the value at (x, y).
+
+ Note that the type of image->get(x, y) is
+ the storage type, not the computation
+ type. If the constructor promoting Storage to Compute rescales values
+ (as, for example Color3(Color3uint8&) does), this will not match the value
+ returned by Map2D::nearest.
+ */
+ inline const Storage& get(int x, int y, WrapMode wrap) const {
+ if (((uint32)x < w) && ((uint32)y < h)) {
+ return data[x + y * w];
+ } else {
+ // Remove the const to allow a slowGet on this object
+ // (we're returning a const reference so this is ok)
+ return const_cast(this)->slowGet(x, y, wrap);
+ }
+# ifndef G3D_WIN32
+ // gcc gives a useless warning that the above code might reach the end of the function;
+ // we use this line to supress the warning.
+ return ZERO;
+# endif
+ }
+
+ inline const Storage& get(int x, int y) const {
+ return get(x, y, _wrapMode);
+ }
+
+ inline const Storage& get(const Vector2int16& p) const {
+ return get(p.x, p.y, _wrapMode);
+ }
+
+ inline const Storage& get(const Vector2int16& p, WrapMode wrap) const {
+ return get(p.x, p.y, wrap);
+ }
+
+ inline Storage& get(int x, int y, WrapMode wrap) {
+ return const_cast(const_cast(this)->get(x, y, wrap));
+# ifndef G3D_WIN32
+ // gcc gives a useless warning that the above code might reach the end of the function;
+ // we use this line to supress the warning.
+ return ZERO;
+# endif
+ }
+
+ inline Storage& get(int x, int y) {
+ return const_cast(const_cast(this)->get(x, y));
+# ifndef G3D_WIN32
+ // gcc gives a useless warning that the above code might reach the end of the function;
+ // we use this line to supress the warning.
+ return ZERO;
+# endif
+ }
+
+ inline Storage& get(const Vector2int16& p) {
+ return get(p.x, p.y);
+ }
+
+ /** Sets the changed flag to true */
+ inline void set(const Vector2int16& p, const Storage& v) {
+ set(p.x, p.y, v);
+ }
+
+ /** Sets the changed flag to true */
+ void set(int x, int y, const Storage& v, WrapMode wrap) {
+ setChanged(true);
+ if (((uint32)x < w) && ((uint32)y < h)) {
+ // In bounds, wrapping isn't an issue.
+ data[x + y * w] = v;
+ } else {
+ const_cast(slowGet(x, y, wrap)) = v;
+ }
+ }
+
+ void set(int x, int y, const Storage& v) {
+ set(x, y, v, _wrapMode);
+ }
+
+
+ void setAll(const Storage& v) {
+ for(int i = 0; i < data.size(); ++i) {
+ data[i] = v;
+ }
+ setChanged(true);
+ }
+
+ /** flips if @a flip is true*/
+ void maybeFlipVertical(bool flip) {
+ if (flip) {
+ flipVertical();
+ }
+ }
+
+ virtual void flipVertical() {
+ int halfHeight = h/2;
+ Storage* d = data.getCArray();
+ for (int y = 0; y < halfHeight; ++y) {
+ int o1 = y * w;
+ int o2 = (h - y - 1) * w;
+ for (int x = 0; x < (int)w; ++x) {
+ int i1 = o1 + x;
+ int i2 = o2 + x;
+ Storage temp = d[i1];
+ d[i1] = d[i2];
+ d[i2] = temp;
+ }
+ }
+ setChanged(true);
+ }
+
+ virtual void flipHorizontal() {
+ int halfWidth = w / 2;
+ Storage* d = data.getCArray();
+ for (int x = 0; x < halfWidth; ++x) {
+ for (int y = 0; y < (int)h; ++y) {
+ int i1 = y * w + x;
+ int i2 = y * w + (w - x - 1);
+ Storage temp = d[i1];
+ d[i1] = d[i2];
+ d[i2] = temp;
+ }
+ }
+ setChanged(true);
+ }
+
+ /**
+ Crops this map so that it only contains pixels between (x, y) and (x + w - 1, y + h - 1) inclusive.
+ */
+ virtual void crop(int newX, int newY, int newW, int newH) {
+ alwaysAssertM(newX + newW <= (int)w, "Cannot grow when cropping");
+ alwaysAssertM(newY + newH <= (int)h, "Cannot grow when cropping");
+ alwaysAssertM(newX >= 0 && newY >= 0, "Origin out of bounds.");
+
+ // Always safe to copy towards the upper left, provided
+ // that we're iterating towards the lower right. This lets us avoid
+ // reallocating the underlying array.
+ for (int y = 0; y < newH; ++y) {
+ for (int x = 0; x < newW; ++x) {
+ data[x + y * newW] = data[(x + newX) + (y + newY) * w];
+ }
+ }
+
+ resize(newW, newH);
+ }
+
+ /** iRounds to the nearest x0 and y0. */
+ virtual void crop(const Rect2D& rect) {
+ crop(iRound(rect.x0()), iRound(rect.y0()), iRound(rect.x1()) - iRound(rect.x0()), iRound(rect.y1()) - iRound(rect.y0()));
+ }
+
+ /** Returns the nearest neighbor. Pixel values are considered
+ to be at the upper left corner, so image->nearest(x, y) == image(x, y)
+ */
+ inline Compute nearest(float x, float y, WrapMode wrap) const {
+ int ix = iRound(x);
+ int iy = iRound(y);
+ return Compute(get(ix, iy, wrap));
+ }
+
+ inline Compute nearest(float x, float y) const {
+ return nearest(x, y, _wrapMode);
+ }
+
+ inline Compute nearest(const Vector2& p) const {
+ return nearest(p.x, p.y);
+ }
+
+ /** Returns the average value of all elements of the map */
+ Compute average() const {
+ if ((w == 0) || (h == 0)) {
+ return ZERO;
+ }
+
+ // To avoid overflows, compute the average of row averages
+
+ Compute rowSum = ZERO;
+ for (unsigned int y = 0; y < h; ++y) {
+ Compute sum = ZERO;
+ int offset = y * w;
+ for (unsigned int x = 0; x < w; ++x) {
+ sum += Compute(data[offset + x]);
+ }
+ rowSum += sum * (1.0f / w);
+ }
+
+ return rowSum * (1.0f / h);
+ }
+
+ /**
+ Needs to access elements from (floor(x), floor(y))
+ to (floor(x) + 1, floor(y) + 1) and will use
+ the wrap mode appropriately (possibly generating
+ out of bounds errors).
+
+ Guaranteed to match nearest(x, y) at integers. */
+ Compute bilinear(float x, float y, WrapMode wrap) const {
+ const int i = iFloor(x);
+ const int j = iFloor(y);
+
+ const float fX = x - i;
+ const float fY = y - j;
+
+ // Horizontal interpolation, first row
+ const Compute& t0 = get(i, j, wrap);
+ const Compute& t1 = get(i + 1, j, wrap);
+
+ // Horizontal interpolation, second row
+ const Compute& t2 = get(i, j + 1, wrap);
+ const Compute& t3 = get(i + 1, j + 1, wrap);
+
+ const Compute& A = lerp(t0, t1, fX);
+ const Compute& B = lerp(t2, t3, fX);
+
+ // Vertical interpolation
+ return lerp(A, B, fY);
+ }
+
+ Compute bilinear(float x, float y) const {
+ return bilinear(x, y, _wrapMode);
+ }
+
+ inline Compute bilinear(const Vector2& p) const {
+ return bilinear(p.x, p.y, _wrapMode);
+ }
+
+ inline Compute bilinear(const Vector2& p, WrapMode wrap) const {
+ return bilinear(p.x, p.y, wrap);
+ }
+
+ /**
+ Uses Catmull-Rom splines to interpolate between grid
+ values. Guaranteed to match nearest(x, y) at integers.
+ */
+ Compute bicubic(float x, float y, WrapMode wrap) const {
+ int i = iFloor(x);
+ int j = iFloor(y);
+ float fX = x - i;
+ float fY = y - j;
+
+ Compute vsample[4];
+ for (int v = 0; v < 4; ++v) {
+
+ // Horizontal interpolation
+ Compute hsample[4];
+ for (int u = 0; u < 4; ++u) {
+ hsample[u] = Compute(get(i + u - 1, j + v - 1, wrap));
+ }
+
+ vsample[v] = bicubic(hsample, fX);
+ }
+
+ // Vertical interpolation
+ return bicubic(vsample, fY);
+ }
+
+ Compute bicubic(float x, float y) const {
+ return bicubic(x, y, _wrapMode);
+ }
+
+ inline Compute bicubic(const Vector2& p, WrapMode wrap) const {
+ return bicubic(p.x, p.y, wrap);
+ }
+
+ inline Compute bicubic(const Vector2& p) const {
+ return bicubic(p.x, p.y, _wrapMode);
+ }
+
+ /** Pixel width */
+ inline int32 width() const {
+ return (int32)w;
+ }
+
+
+ /** Pixel height */
+ inline int32 height() const {
+ return (int32)h;
+ }
+
+
+ /** Dimensions in pixels */
+ Vector2int16 size() const {
+ return Vector2int16(w, h);
+ }
+
+ /** Rectangle from (0, 0) to (w, h) */
+ Rect2D rect2DBounds() const {
+ return Rect2D::xywh(0, 0, w, h);
+ }
+
+ /** Number of bytes occupied by the image data and this structure */
+ size_t sizeInMemory() const {
+ return data.size() * sizeof(Storage) + sizeof(*this);
+ }
+
+
+ WrapMode wrapMode() const {
+ return _wrapMode;
+ }
+
+
+ void setWrapMode(WrapMode m) {
+ _wrapMode = m;
+ }
+};
+
+
+
+}
+
+#endif // G3D_IMAGE_H
diff --git a/dep/include/g3dlite/G3D/Matrix.h b/dep/include/g3dlite/G3D/Matrix.h
new file mode 100644
index 000000000..3c5394d9a
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Matrix.h
@@ -0,0 +1,634 @@
+/**
+ @file Matrix.h
+ @author Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2005-10-23
+ @edited 2007-07-18
+ */
+
+#ifndef G3D_MATRIX_H
+#define G3D_MATRIX_H
+
+#include "G3D/g3dmath.h"
+#include "G3D/Vector3.h"
+#include "G3D/Vector4.h"
+#include "G3D/Matrix3.h"
+#include "G3D/Matrix4.h"
+#include "G3D/ReferenceCount.h"
+
+namespace G3D {
+
+/**
+ N x M matrix.
+
+ The actual data is tracked internally by a reference counted pointer;
+ it is efficient to pass and assign Matrix objects because no data is actually copied.
+ This avoids the headache of pointers and allows natural math notation:
+
+
+ Matrix A, B, C;
+ // ...
+
+ C = A * f(B);
+ C = C.inverse();
+
+ A = Matrix::identity(4);
+ C = A;
+ C.set(0, 0, 2.0); // Triggers a copy of the data so that A remains unchanged.
+
+ // etc.
+
+
+
+ The Matrix::debugNumCopyOps and Matrix::debugNumAllocOps counters
+ increment every time an operation forces the copy and allocation of matrices. You
+ can use these to detect slow operations when efficiency is a major concern.
+
+ Some methods accept an output argument instead of returning a value. For example,
+ A = B.transpose() can also be invoked as B.transpose(A).
+ The latter may be more efficient, since Matrix may be able to re-use the storage of
+ A (if it has approximatly the right size and isn't currently shared with another matrix).
+
+ @sa G3D::Matrix3, G3D::Matrix4, G3D::Vector2, G3D::Vector3, G3D::Vector4, G3D::CoordinateFrame
+
+ @beta
+ */
+class Matrix {
+public:
+ /**
+ Internal precision. Currently float, but this may become a templated class in the future
+ to allow operations like Matrix and Matrix.
+
+ Not necessarily a plain-old-data type (e.g., could ComplexFloat), but must be something
+ with no constructor, that can be safely memcpyd, and that has a bit pattern of all zeros
+ when zero.*/
+ typedef float T;
+
+ /** Incremented every time the elements of a matrix are copied. Useful for profiling your
+ own code that uses Matrix to determine when it is slow due to copying.*/
+ static int debugNumCopyOps;
+
+ /** Incremented every time a new matrix object is allocated. Useful for profiling your
+ own code that uses Matrix to determine when it is slow due to allocation.*/
+ static int debugNumAllocOps;
+
+private:
+public:
+
+ /** Used internally by Matrix.
+
+ Does not throw exceptions-- assumes the caller has taken care of
+ argument checking. */
+ class Impl : public ReferenceCountedObject {
+ public:
+
+ static void* operator new(size_t size) {
+ return System::malloc(size);
+ }
+
+ static void operator delete(void* p) {
+ System::free(p);
+ }
+
+ ~Impl();
+
+ private:
+ friend class Matrix;
+
+ /** elt[r][c] = the element. Pointers into data.*/
+ T** elt;
+
+ /** Row major data for the entire matrix. */
+ T* data;
+
+ /** The number of rows */
+ int R;
+
+ /** The number of columns */
+ int C;
+
+ int dataSize;
+
+ /** If R*C is much larger or smaller than the current, deletes all previous data
+ and resets to random data. Otherwise re-uses existing memory and just resets
+ R, C, and the row pointers. */
+ void setSize(int newRows, int newCols);
+
+ inline Impl() : elt(NULL), data(NULL), R(0), C(0), dataSize(0) {}
+
+ Impl(const Matrix3& M);
+
+ Impl(const Matrix4& M);
+
+ inline Impl(int r, int c) : elt(NULL), data(NULL), R(0), C(0), dataSize(0) {
+ setSize(r, c);
+ }
+
+ Impl& operator=(const Impl& m);
+
+ inline Impl(const Impl& B) : elt(NULL), data(NULL), R(0), C(0), dataSize(0) {
+ // Use the assignment operator
+ *this = B;
+ }
+
+ void setZero();
+
+ inline void set(int r, int c, T v) {
+ debugAssert(r < R);
+ debugAssert(c < C);
+ elt[r][c] = v;
+ }
+
+ inline const T& get(int r, int c) const {
+ debugAssert(r < R);
+ debugAssert(c < C);
+ return elt[r][c];
+ }
+
+ /** Multiplies this by B and puts the result in out. */
+ void mul(const Impl& B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void add(const Impl& B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void add(T B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void sub(const Impl& B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void sub(T B, Impl& out) const;
+
+ /** B - this */
+ void lsub(T B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void arrayMul(const Impl& B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void mul(T B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void arrayDiv(const Impl& B, Impl& out) const;
+
+ /** Ok if out == this or out == B */
+ void div(T B, Impl& out) const;
+
+ void negate(Impl& out) const;
+
+ /** Slow way of computing an inverse; for reference */
+ void inverseViaAdjoint(Impl& out) const;
+
+ /** Use Gaussian elimination with pivots to solve for the inverse destructively in place. */
+ void inverseInPlaceGaussJordan();
+
+ void adjoint(Impl& out) const;
+
+ /** Matrix of all cofactors */
+ void cofactor(Impl& out) const;
+
+ /**
+ Cofactor [r][c] is defined as C[r][c] = -1 ^(r+c) * det(A[r][c]),
+ where A[r][c] is the (R-1)x(C-1) matrix formed by removing row r and
+ column c from the original matrix.
+ */
+ T cofactor(int r, int c) const;
+
+ /** Ok if out == this or out == B */
+ void transpose(Impl& out) const;
+
+ T determinant() const;
+
+ /** Determinant computed without the given row and column */
+ T determinant(int r, int c) const;
+
+ void arrayLog(Impl& out) const;
+
+ void arrayExp(Impl& out) const;
+
+ void arraySqrt(Impl& out) const;
+
+ void arrayCos(Impl& out) const;
+
+ void arraySin(Impl& out) const;
+
+ void swapRows(int r0, int r1);
+
+ void swapAndNegateCols(int c0, int c1);
+
+ void mulRow(int r, const T& v);
+
+ void abs(Impl& out) const;
+
+ /** Makes a (R-1)x(C-1) copy of this matrix */
+ void withoutRowAndCol(int excludeRow, int excludeCol, Impl& out) const;
+
+ bool anyNonZero() const;
+
+ bool allNonZero() const;
+
+ void setRow(int r, const T* vals);
+
+ void setCol(int c, const T* vals);
+ };
+private:
+
+ typedef ReferenceCountedPointer ImplRef;
+
+ ImplRef impl;
+
+ inline Matrix(ImplRef i) : impl(i) {}
+ inline Matrix(Impl* i) : impl(ImplRef(i)) {}
+
+ /** Used by SVD */
+ class SortRank {
+ public:
+ T value;
+ int col;
+
+ inline bool operator>(const SortRank& x) const {
+ return x.value > value;
+ }
+
+ inline bool operator<(const SortRank& x) const {
+ return x.value < value;
+ }
+
+ inline bool operator>=(const SortRank& x) const {
+ return x.value >= value;
+ }
+
+ inline bool operator<=(const SortRank& x) const {
+ return x.value <= value;
+ }
+
+ inline bool operator==(const SortRank& x) const {
+ return x.value == value;
+ }
+
+ inline bool operator!=(const SortRank& x) const {
+ return x.value != value;
+ }
+ };
+
+ Matrix vectorPseudoInverse() const;
+ Matrix partitionPseudoInverse() const;
+ Matrix colPartPseudoInverse() const;
+ Matrix rowPartPseudoInverse() const;
+
+ Matrix col2PseudoInverse(const Matrix& B) const;
+ Matrix col3PseudoInverse(const Matrix& B) const;
+ Matrix col4PseudoInverse(const Matrix& B) const;
+ Matrix row2PseudoInverse(const Matrix& B) const;
+ Matrix row3PseudoInverse(const Matrix& B) const;
+ Matrix row4PseudoInverse(const Matrix& B) const;
+
+public:
+
+ Matrix() : impl(new Impl(0, 0)) {}
+
+ Matrix(const Matrix3& M) : impl(new Impl(M)) {}
+
+ Matrix(const Matrix4& M) : impl(new Impl(M)) {}
+
+ template
+ static Matrix fromDiagonal(const Array& d) {
+ Matrix D = zero(d.length(), d.length());
+ for (int i = 0; i < d.length(); ++i) {
+ D.set(i, i, d[i]);
+ }
+ return D;
+ }
+
+ static Matrix fromDiagonal(const Matrix& d);
+
+ /** Returns a new matrix that is all zero. */
+ Matrix(int R, int C) : impl(new Impl(R, C)) {
+ impl->setZero();
+ }
+
+ /** Returns a new matrix that is all zero. */
+ static Matrix zero(int R, int C);
+
+ /** Returns a new matrix that is all one. */
+ static Matrix one(int R, int C);
+
+ /** Returns a new identity matrix */
+ static Matrix identity(int N);
+
+ /** Uniformly distributed values between zero and one. */
+ static Matrix random(int R, int C);
+
+ /** The number of rows */
+ inline int rows() const {
+ return impl->R;
+ }
+
+ /** Number of columns */
+ inline int cols() const {
+ return impl->C;
+ }
+
+ /** Generally more efficient than A * B */
+ Matrix& operator*=(const T& B);
+
+ /** Generally more efficient than A / B */
+ Matrix& operator/=(const T& B);
+
+ /** Generally more efficient than A + B */
+ Matrix& operator+=(const T& B);
+
+ /** Generally more efficient than A - B */
+ Matrix& operator-=(const T& B);
+
+ /** No performance advantage over A * B because
+ matrix multiplication requires intermediate
+ storage. */
+ Matrix& operator*=(const Matrix& B);
+
+ /** Generally more efficient than A + B */
+ Matrix& operator+=(const Matrix& B);
+
+ /** Generally more efficient than A - B */
+ Matrix& operator-=(const Matrix& B);
+
+ /** Returns a new matrix that is a subset of this one,
+ from r1:r2 to c1:c2, inclusive.*/
+ Matrix subMatrix(int r1, int r2, int c1, int c2) const;
+
+ /** Matrix multiplication. To perform element-by-element multiplication,
+ see arrayMul. */
+ inline Matrix operator*(const Matrix& B) const {
+ Matrix C(impl->R, B.impl->C);
+ impl->mul(*B.impl, *C.impl);
+ return C;
+ }
+
+ /** See also A *= B, which is more efficient in many cases */
+ inline Matrix operator*(const T& B) const {
+ Matrix C(impl->R, impl->C);
+ impl->mul(B, *C.impl);
+ return C;
+ }
+
+ /** See also A += B, which is more efficient in many cases */
+ inline Matrix operator+(const Matrix& B) const {
+ Matrix C(impl->R, impl->C);
+ impl->add(*B.impl, *C.impl);
+ return C;
+ }
+
+ /** See also A -= B, which is more efficient in many cases */
+ inline Matrix operator-(const Matrix& B) const {
+ Matrix C(impl->R, impl->C);
+ impl->sub(*B.impl, *C.impl);
+ return C;
+ }
+
+ /** See also A += B, which is more efficient in many cases */
+ inline Matrix operator+(const T& v) const {
+ Matrix C(impl->R, impl->C);
+ impl->add(v, *C.impl);
+ return C;
+ }
+
+ /** See also A -= B, which is more efficient in many cases */
+ inline Matrix operator-(const T& v) const {
+ Matrix C(impl->R, impl->C);
+ impl->sub(v, *C.impl);
+ return C;
+ }
+
+
+ Matrix operator>(const T& scalar) const;
+
+ Matrix operator<(const T& scalar) const;
+
+ Matrix operator>=(const T& scalar) const;
+
+ Matrix operator<=(const T& scalar) const;
+
+ Matrix operator==(const T& scalar) const;
+
+ Matrix operator!=(const T& scalar) const;
+
+ /** scalar B - this */
+ inline Matrix lsub(const T& B) const {
+ Matrix C(impl->R, impl->C);
+ impl->lsub(B, *C.impl);
+ return C;
+ }
+
+ inline Matrix arrayMul(const Matrix& B) const {
+ Matrix C(impl->R, impl->C);
+ impl->arrayMul(*B.impl, *C.impl);
+ return C;
+ }
+
+ Matrix3 toMatrix3() const;
+
+ Matrix4 toMatrix4() const;
+
+ Vector2 toVector2() const;
+
+ Vector3 toVector3() const;
+
+ Vector4 toVector4() const;
+
+ /** Mutates this */
+ void arrayMulInPlace(const Matrix& B);
+
+ /** Mutates this */
+ void arrayDivInPlace(const Matrix& B);
+
+ // Declares an array unary method and its explicit-argument counterpart
+# define DECLARE_METHODS_1(method)\
+ inline Matrix method() const {\
+ Matrix C(impl->R, impl->C);\
+ impl->method(*C.impl);\
+ return C;\
+ }\
+ void method(Matrix& out) const;
+
+
+ DECLARE_METHODS_1(abs)
+ DECLARE_METHODS_1(arrayLog)
+ DECLARE_METHODS_1(arrayExp)
+ DECLARE_METHODS_1(arraySqrt)
+ DECLARE_METHODS_1(arrayCos)
+ DECLARE_METHODS_1(arraySin)
+ DECLARE_METHODS_1(negate)
+
+# undef DECLARE_METHODS_1
+
+ inline Matrix operator-() const {
+ return negate();
+ }
+
+ /**
+ A-1 computed using the Gauss-Jordan algorithm,
+ for square matrices.
+ Run time is O(R3), where R is the
+ number of rows.
+ */
+ inline Matrix inverse() const {
+ Impl* A = new Impl(*impl);
+ A->inverseInPlaceGaussJordan();
+ return Matrix(A);
+ }
+
+ inline T determinant() const {
+ return impl->determinant();
+ }
+
+ /**
+ AT
+ */
+ inline Matrix transpose() const {
+ Impl* A = new Impl(cols(), rows());
+ impl->transpose(*A);
+ return Matrix(A);
+ }
+
+ /** Transpose in place; more efficient than transpose */
+ void transpose(Matrix& out) const;
+
+ inline Matrix adjoint() const {
+ Impl* A = new Impl(cols(), rows());
+ impl->adjoint(*A);
+ return Matrix(A);
+ }
+
+ /**
+ (ATA)-1AT) computed
+ using SVD.
+
+ @param tolerance Use -1 for automatic tolerance.
+ */
+ Matrix pseudoInverse(float tolerance = -1) const;
+
+ /** Called from pseudoInverse when the matrix has size > 4 along some dimension.*/
+ Matrix svdPseudoInverse(float tolerance = -1) const;
+
+ /**
+ (ATA)-1AT) computed
+ using Gauss-Jordan elimination.
+ */
+ inline Matrix gaussJordanPseudoInverse() const {
+ Matrix trans = transpose();
+ return (trans * (*this)).inverse() * trans;
+ }
+
+ /** Singular value decomposition. Factors into three matrices
+ such that @a this = @a U * fromDiagonal(@a d) * @a V.transpose().
+
+ The matrix must have at least as many rows as columns.
+
+ Run time is O(C2*R).
+
+ @param sort If true (default), the singular values
+ are arranged so that D is sorted from largest to smallest.
+ */
+ void svd(Matrix& U, Array& d, Matrix& V, bool sort = true) const;
+
+ void set(int r, int c, T v);
+
+ void setCol(int c, const Matrix& vec);
+
+ void setRow(int r, const Matrix& vec);
+
+ Matrix col(int c) const;
+
+ Matrix row(int r) const;
+
+ T get(int r, int c) const;
+
+ Vector2int16 size() const {
+ return Vector2int16(rows(), cols());
+ }
+
+ int numElements() const {
+ return rows() * cols();
+ }
+
+ void swapRows(int r0, int r1);
+
+ /** Swaps columns c0 and c1 and negates both */
+ void swapAndNegateCols(int c0, int c1);
+
+ void mulRow(int r, const T& v);
+
+ /** Returns true if any element is non-zero */
+ bool anyNonZero() const;
+
+ /** Returns true if all elements are non-zero */
+ bool allNonZero() const;
+
+ inline bool allZero() const {
+ return !anyNonZero();
+ }
+
+ inline bool anyZero() const {
+ return !allNonZero();
+ }
+
+ /** Serializes in Matlab source format */
+ void serialize(TextOutput& t) const;
+
+ std::string toString(const std::string& name) const;
+
+ std::string toString() const {
+ static const std::string name = "";
+ return toString(name);
+ }
+
+ /** 2-norm squared: sum(squares). (i.e., dot product with itself) */
+ double normSquared() const;
+
+ /** 2-norm (sqrt(sum(squares)) */
+ double norm() const;
+
+ /**
+ Low-level SVD functionality. Useful for applications that do not want
+ to construct a Matrix but need to perform the SVD operation.
+
+ this = U * D * V'
+
+ Assumes that rows >= cols
+
+ @return NULL on success, a string describing the error on failure.
+ @param U rows x cols matrix to be decomposed, gets overwritten with U, a rows x cols matrix with orthogonal columns.
+ @param D vector of singular values of a (diagonal of the D matrix). Length cols.
+ @param V returns the right orthonormal transformation matrix, size cols x cols
+
+ @cite Based on Dianne Cook's implementation, which is adapted from
+ svdecomp.c in XLISP-STAT 2.1, which is code from Numerical Recipes
+ adapted by Luke Tierney and David Betz. The Numerical Recipes code
+ is adapted from Forsythe et al, who based their code on Golub and
+ Reinsch's original implementation.
+ */
+ static const char* svdCore(float** U, int rows, int cols, float* D, float** V);
+
+};
+
+}
+
+inline G3D::Matrix operator-(const G3D::Matrix::T& v, const G3D::Matrix& M) {
+ return M.lsub(v);
+}
+
+inline G3D::Matrix operator*(const G3D::Matrix::T& v, const G3D::Matrix& M) {
+ return M * v;
+}
+
+inline G3D::Matrix operator+(const G3D::Matrix::T& v, const G3D::Matrix& M) {
+ return M + v;
+}
+
+inline G3D::Matrix abs(const G3D::Matrix& M) {
+ return M.abs();
+}
+
+#endif
+
diff --git a/dep/include/g3dlite/G3D/Matrix2.h b/dep/include/g3dlite/G3D/Matrix2.h
new file mode 100644
index 000000000..eaf4aefa2
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Matrix2.h
@@ -0,0 +1,69 @@
+#ifndef G3D_MATRIX2_H
+#define G3D_MATRIX2_H
+
+#include "G3D/platform.h"
+#include "G3D/Vector2.h"
+
+namespace G3D {
+
+/** @beta */
+class Matrix2 {
+private:
+
+ float data[2][2];
+
+public:
+
+ inline Matrix2() {
+ data[0][0] = 1.0f; data[0][1] = 0.0f;
+ data[1][0] = 0.0f; data[1][1] = 1.0f;
+ }
+
+ inline Matrix2(float v00, float v01, float v10, float v11) {
+ data[0][0] = v00; data[0][1] = v01;
+ data[1][0] = v10; data[1][1] = v11;
+ }
+
+ inline Vector2 operator*(const Vector2& v) const {
+ return Vector2(data[0][0] * v[0] + data[0][1] * v[1],
+ data[1][0] * v[0] + data[1][1] * v[1]);
+ }
+
+ inline Matrix2 inverse() const {
+ return Matrix2(data[0][0], data[1][0],
+ data[0][1], data[1][1]) * (1.0f / determinant());
+ }
+
+ inline Matrix2 transpose() const {
+ return Matrix2(data[0][0], data[1][0],
+ data[0][1], data[1][1]);
+ }
+
+ inline float determinant() const {
+ return data[0][0] * data[1][1] - data[0][1] * data[1][0];
+ }
+
+ inline Matrix2 operator*(float f) const {
+ return Matrix2(data[0][0] * f, data[0][1] * f,
+ data[1][0] * f, data[1][1] * f);
+ }
+
+ inline Matrix2 operator/(float f) const {
+ return Matrix2(data[0][0] / f, data[0][1] / f,
+ data[1][0] / f, data[1][1] / f);
+ }
+
+ inline float* operator[](int i) {
+ debugAssert(i >= 0 && i <= 2);
+ return data[i];
+ }
+
+ inline const float* operator[](int i) const {
+ debugAssert(i >= 0 && i <= 1);
+ return data[i];
+ }
+};
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/Matrix3.h b/dep/include/g3dlite/G3D/Matrix3.h
index 19eda497a..06ec7e674 100644
--- a/dep/include/g3dlite/G3D/Matrix3.h
+++ b/dep/include/g3dlite/G3D/Matrix3.h
@@ -3,7 +3,7 @@
3x3 matrix class
- @maintainer Morgan McGuire, matrix@graphics3d.com
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
@cite Portions based on Dave Eberly's Magic Software Library at http://www.magic-software.com
@@ -11,16 +11,26 @@
@edited 2006-04-05
*/
-#ifndef G3D_MATRIX3_H
-#define G3D_MATRIX3_H
+#ifndef G3D_Matrix3_h
+#define G3D_Matrix3_h
#include "G3D/platform.h"
-#include "G3D/System.h"
#include "G3D/Vector3.h"
#include "G3D/Vector4.h"
+#include "G3D/debugAssert.h"
+
+#include
namespace G3D {
+#ifdef _MSC_VER
+// Turn off "conditional expression is constant" warning; MSVC generates this
+// for debug assertions in inlined methods.
+# pragma warning (disable : 4127)
+#endif
+
+class Any;
+
/**
3x3 matrix. Do not subclass.
*/
@@ -37,23 +47,33 @@ private:
public:
+ Matrix3(const Any& any);
+
+ operator Any() const;
+
/** Initial values are undefined for performance. See also
Matrix3::zero(), Matrix3::identity(), Matrix3::fromAxisAngle, etc.*/
inline Matrix3() {}
+ Matrix3 (class BinaryInput& b);
Matrix3 (const float aafEntry[3][3]);
Matrix3 (const Matrix3& rkMatrix);
Matrix3 (float fEntry00, float fEntry01, float fEntry02,
float fEntry10, float fEntry11, float fEntry12,
float fEntry20, float fEntry21, float fEntry22);
- bool fuzzyEq(const Matrix3& b) const;
+ bool fuzzyEq(const Matrix3& b) const;
/** Constructs a matrix from a quaternion.
@cite Graphics Gems II, p. 351--354
@cite Implementation from Watt and Watt, pg 362*/
Matrix3(const class Quat& q);
+ void serialize(class BinaryOutput& b) const;
+ void deserialize(class BinaryInput& b);
+
+ /** Returns true if column(0).cross(column(1)).dot(column(2)) > 0. */
+ bool isRightHanded() const;
/**
Sets all elements.
@@ -84,15 +104,16 @@ public:
inline operator const float* () const{
return (const float*)&elt[0][0];
}
+
+ Vector3 column(int c) const;
+ const Vector3& row(int r) const;
- Vector3 getColumn (int iCol) const;
- Vector3 getRow (int iRow) const;
void setColumn(int iCol, const Vector3 &vector);
void setRow(int iRow, const Vector3 &vector);
// assignment and comparison
inline Matrix3& operator= (const Matrix3& rkMatrix) {
- System::memcpy(elt, rkMatrix.elt, 9 * sizeof(float));
+ memcpy(elt, rkMatrix.elt, 9 * sizeof(float));
return *this;
}
@@ -143,6 +164,10 @@ public:
friend Matrix3 operator* (float fScalar, const Matrix3& rkMatrix);
friend Matrix3 operator* (int fScalar, const Matrix3& rkMatrix);
+ Matrix3& operator*= (float k);
+ Matrix3& operator/= (float k);
+
+
private:
/** Multiplication where out != A and out != B */
static void _mul(const Matrix3& A, const Matrix3& B, Matrix3& out);
@@ -202,11 +227,46 @@ public:
void qDUDecomposition (Matrix3& rkQ, Vector3& rkD,
Vector3& rkU) const;
+ /**
+ Polar decomposition of a matrix. Based on pseudocode from Nicholas J
+ Higham, "Computing the Polar Decomposition -- with Applications Siam
+ Journal of Science and Statistical Computing, Vol 7, No. 4, October
+ 1986.
+
+ Decomposes A into R*S, where R is orthogonal and S is symmetric.
+
+ Ken Shoemake's "Matrix animation and polar decomposition"
+ in Proceedings of the conference on Graphics interface '92
+ seems to be better known in the world of graphics, but Higham's version
+ uses a scaling constant that can lead to faster convergence than
+ Shoemake's when the initial matrix is far from orthogonal.
+ */
+ void polarDecomposition(Matrix3 &R, Matrix3 &S) const;
+
+ /**
+ * Matrix norms.
+ */
float spectralNorm () const;
+ float squaredFrobeniusNorm() const;
+
+ float frobeniusNorm() const;
+
+ float l1Norm() const;
+
+ float lInfNorm() const;
+
+ float diffOneNorm(const Matrix3 &y) const;
+
/** matrix must be orthonormal */
void toAxisAngle(Vector3& rkAxis, float& rfRadians) const;
+ static Matrix3 fromDiagonal(const Vector3& d) {
+ return Matrix3(d.x, 0, 0,
+ 0, d.y, 0,
+ 0, 0, d.z);
+ }
+
static Matrix3 fromAxisAngle(const Vector3& rkAxis, float fRadians);
/**
@@ -239,7 +299,7 @@ public:
static void tensorProduct (const Vector3& rkU, const Vector3& rkV,
Matrix3& rkProduct);
- std::string toString() const;
+ std::string toString() const;
static const float EPSILON;
@@ -252,7 +312,7 @@ public:
// "You might be tempted to write [...] them as inline functions
// inside their respective header files, but this is something you
// must definitely not do. An inline function can be duplicated
- // in every file in which it appears and this duplication
+ // in every file in which it appears and this duplication
// includes the static object definition. Because inline functions
// automatically default to internal linkage, this would result in
// having multiple static objects across the various translation
@@ -264,13 +324,8 @@ public:
static const Matrix3& zero();
static const Matrix3& identity();
- // Deprecated.
- /** @deprecated Use Matrix3::zero() */
- static const Matrix3 ZERO;
- /** @deprecated Use Matrix3::identity() */
- static const Matrix3 IDENTITY;
-
protected:
+
// support for eigensolver
void tridiagonal (float afDiag[3], float afSubDiag[3]);
bool qLAlgorithm (float afDiag[3], float afSubDiag[3]);
diff --git a/dep/include/g3dlite/G3D/Matrix4.h b/dep/include/g3dlite/G3D/Matrix4.h
new file mode 100644
index 000000000..9ce87d875
--- /dev/null
+++ b/dep/include/g3dlite/G3D/Matrix4.h
@@ -0,0 +1,249 @@
+/**
+ @file Matrix4.h
+
+ 4x4 matrix class
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-10-02
+ @edited 2009-10-20
+ */
+
+#ifndef G3D_Matrix4_h
+#define G3D_Matrix4_h
+
+#ifdef _MSC_VER
+// Disable conditional expression is constant, which occurs incorrectly on inlined functions
+# pragma warning (push)
+# pragma warning( disable : 4127 )
+#endif
+
+#include "G3D/platform.h"
+#include "G3D/debugAssert.h"
+#include "G3D/Matrix3.h"
+#include "G3D/Vector3.h"
+
+namespace G3D {
+
+class Any;
+
+/**
+ A 4x4 matrix.
+
+ See also G3D::CoordinateFrame, G3D::Matrix3, G3D::Quat
+ */
+class Matrix4 {
+private:
+
+ float elt[4][4];
+
+ /**
+ Computes the determinant of the 3x3 matrix that lacks excludeRow
+ and excludeCol.
+ */
+ float subDeterminant(int excludeRow, int excludeCol) const;
+
+ // Hidden operators
+ bool operator<(const Matrix4&) const;
+ bool operator>(const Matrix4&) const;
+ bool operator<=(const Matrix4&) const;
+ bool operator>=(const Matrix4&) const;
+
+public:
+ /** Must be of the form: Matrix4(#, #, # .... #)*/
+ Matrix4(const Any& any);
+
+ operator Any() const;
+
+ Matrix4(
+ float r1c1, float r1c2, float r1c3, float r1c4,
+ float r2c1, float r2c2, float r2c3, float r2c4,
+ float r3c1, float r3c2, float r3c3, float r3c4,
+ float r4c1, float r4c2, float r4c3, float r4c4);
+
+ /**
+ init should be row major.
+ */
+ Matrix4(const float* init);
+
+ /**
+ a is the upper left 3x3 submatrix and b is the upper right 3x1 submatrix. The last row of the created matrix is (0,0,0,1).
+ */
+ Matrix4(const class Matrix3& upper3x3, const class Vector3& lastCol = Vector3::zero());
+
+ Matrix4(const class CoordinateFrame& c);
+
+ Matrix4(const double* init);
+
+ Matrix4();
+
+ /** Produces an RT transformation that nearly matches this Matrix4.
+ Because a Matrix4 may not be precisely a rotation and translation,
+ this may introduce error. */
+ class CoordinateFrame approxCoordinateFrame() const;
+
+ // Special values.
+ // Intentionally not inlined: see Matrix3::identity() for details.
+ static const Matrix4& identity();
+ static const Matrix4& zero();
+
+ /** If this is a perspective projection matrix created by
+ Matrix4::perspectiveProjection, extract its parameters. */
+ void getPerspectiveProjectionParameters
+ (float& left,
+ float& right,
+ float& bottom,
+ float& top,
+ float& nearval,
+ float& farval,
+ float updirection = -1.0f) const;
+
+ inline float* operator[](int r) {
+ debugAssert(r >= 0);
+ debugAssert(r < 4);
+ return (float*)&elt[r];
+ }
+
+ inline const float* operator[](int r) const {
+ debugAssert(r >= 0);
+ debugAssert(r < 4);
+ return (const float*)&elt[r];
+ }
+
+ inline operator float* () {
+ return (float*)&elt[0][0];
+ }
+
+ inline operator const float* () const {
+ return (const float*)&elt[0][0];
+ }
+
+ Matrix4 operator*(const Matrix4& other) const;
+
+ class Matrix3 upper3x3() const;
+
+ /** Homogeneous multiplication. Let k = M * [v w]^T. result = k.xyz() / k.w */
+ class Vector3 homoMul(const class Vector3& v, float w) const;
+
+ /**
+ Constructs an orthogonal projection matrix from the given parameters.
+ Near and far are the NEGATIVE of the near and far plane Z values
+ (to follow OpenGL conventions).
+
+ \param upDirection Use -1.0 for 2D Y increasing downwards (the G3D 8.x default convention),
+ 1.0 for 2D Y increasing upwards (the G3D 7.x default and OpenGL convention)
+ */
+ static Matrix4 orthogonalProjection(
+ float left,
+ float right,
+ float bottom,
+ float top,
+ float nearval,
+ float farval,
+ float upDirection = -1.0f);
+
+
+ /** \param upDirection Use -1.0 for 2D Y increasing downwards (the G3D 8.x default convention),
+ 1.0 for 2D Y increasing upwards (the G3D 7.x default and OpenGL convention)
+ */
+ static Matrix4 orthogonalProjection(
+ const class Rect2D& rect,
+ float nearval,
+ float farval,
+ float upDirection = -1.0f);
+
+ /** \param upDirection Use -1.0 for 2D Y increasing downwards (the G3D 8.x default convention),
+ 1.0 for 2D Y increasing upwards (the G3D 7.x default and OpenGL convention)
+ */
+ static Matrix4 perspectiveProjection(
+ float left,
+ float right,
+ float bottom,
+ float top,
+ float nearval,
+ float farval,
+ float upDirection = -1.0f);
+
+ void setRow(int r, const class Vector4& v);
+ void setColumn(int c, const Vector4& v);
+
+ const Vector4& row(int r) const;
+ Vector4 column(int c) const;
+
+ Matrix4 operator*(const float s) const;
+ Vector4 operator*(const Vector4& vector) const;
+
+ Matrix4 transpose() const;
+
+ bool operator!=(const Matrix4& other) const;
+ bool operator==(const Matrix4& other) const;
+
+ float determinant() const;
+ Matrix4 inverse() const;
+
+ /**
+ Transpose of the cofactor matrix (used in computing the inverse).
+ Note: This is in fact only one type of adjoint. More generally,
+ an adjoint of a matrix is any mapping of a matrix which possesses
+ certain properties. This returns the so-called adjugate
+ or classical adjoint.
+ */
+ Matrix4 adjoint() const;
+ Matrix4 cofactor() const;
+
+ /** Serializes row-major */
+ void serialize(class BinaryOutput& b) const;
+ void deserialize(class BinaryInput& b);
+
+ std::string toString() const;
+
+ /** 3D scale matrix */
+ inline static Matrix4 scale(const Vector3& v) {
+ return Matrix4(v.x, 0, 0, 0,
+ 0, v.y, 0, 0,
+ 0, 0, v.z, 0,
+ 0, 0, 0, 1);
+ }
+
+ /** 3D scale matrix */
+ inline static Matrix4 scale(float x, float y, float z) {
+ return scale(Vector3(x, y, z));
+ }
+
+ /** 3D scale matrix */
+ inline static Matrix4 scale(float s) {
+ return scale(s,s,s);
+ }
+
+ /** 3D translation matrix */
+ inline static Matrix4 translation(const Vector3& v) {
+ return Matrix4(Matrix3::identity(), v);
+ }
+
+ inline static Matrix4 translation(float x, float y, float z) {
+ return Matrix4(Matrix3::identity(), Vector3(x, y, z));
+ }
+
+ /** Create a rotation matrix that rotates \a deg degrees around the Y axis */
+ inline static Matrix4 yawDegrees(float deg) {
+ return Matrix4(Matrix3::fromAxisAngle(Vector3::unitY(), toRadians(deg)));
+ }
+
+ inline static Matrix4 pitchDegrees(float deg) {
+ return Matrix4(Matrix3::fromAxisAngle(Vector3::unitX(), toRadians(deg)));
+ }
+
+ inline static Matrix4 rollDegrees(float deg) {
+ return Matrix4(Matrix3::fromAxisAngle(Vector3::unitZ(), toRadians(deg)));
+ }
+};
+
+
+
+} // namespace
+
+#ifdef _MSC_VER
+# pragma warning (pop)
+#endif
+
+#endif
diff --git a/dep/include/g3dlite/G3D/MemoryManager.h b/dep/include/g3dlite/G3D/MemoryManager.h
new file mode 100644
index 000000000..15bf6d8be
--- /dev/null
+++ b/dep/include/g3dlite/G3D/MemoryManager.h
@@ -0,0 +1,93 @@
+/**
+ @file MemoryManager.h
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+ @created 2009-04-20
+ @edited 2009-04-20
+
+ Copyright 2000-2009, Morgan McGuire.
+ All rights reserved.
+ */
+#ifndef G3D_MemoryManager_h
+#define G3D_MemoryManager_h
+
+#include "G3D/platform.h"
+#include "G3D/ReferenceCount.h"
+
+namespace G3D {
+
+/**
+ Abstraction of memory management.
+ Default implementation uses G3D::System::malloc and is threadsafe.
+
+ \sa CRTMemoryManager, AlignedMemoryManager, AreaMemoryManager */
+class MemoryManager : public ReferenceCountedObject {
+protected:
+
+ MemoryManager();
+
+public:
+
+ typedef ReferenceCountedPointer Ref;
+
+ /** Return a pointer to \a s bytes of memory that are unused by
+ the rest of the program. The contents of the memory are
+ undefined */
+ virtual void* alloc(size_t s);
+
+ /** Invoke to declare that this memory will no longer be used by
+ the program. The memory manager is not required to actually
+ reuse or release this memory. */
+ virtual void free(void* ptr);
+
+ /** Returns true if this memory manager is threadsafe (i.e., alloc
+ and free can be called asychronously) */
+ virtual bool isThreadsafe() const;
+
+ /** Return the instance. There's only one instance of the default
+ MemoryManager; it is cached after the first creation. */
+ static MemoryManager::Ref create();
+};
+
+/**
+ Allocates memory on 16-byte boundaries.
+ \sa MemoryManager, CRTMemoryManager, AreaMemoryManager */
+class AlignedMemoryManager : public MemoryManager {
+protected:
+
+ AlignedMemoryManager();
+
+public:
+
+ typedef ReferenceCountedPointer Ref;
+
+
+ virtual void* alloc(size_t s);
+
+ virtual void free(void* ptr);
+
+ virtual bool isThreadsafe() const;
+
+ static AlignedMemoryManager::Ref create();
+};
+
+
+/** MemoryManager implemented using the C runtime. */
+class CRTMemoryManager : public MemoryManager {
+protected:
+ CRTMemoryManager();
+
+public:
+ typedef ReferenceCountedPointer Ref;
+ virtual void* alloc(size_t s);
+ virtual void free(void* ptr);
+ virtual bool isThreadsafe() const;
+
+ /** There's only one instance of this memory manager; it is
+ cached after the first creation. */
+ static CRTMemoryManager::Ref create();
+};
+
+}
+
+#endif
diff --git a/dep/include/g3dlite/G3D/MeshAlg.h b/dep/include/g3dlite/G3D/MeshAlg.h
new file mode 100644
index 000000000..1decea101
--- /dev/null
+++ b/dep/include/g3dlite/G3D/MeshAlg.h
@@ -0,0 +1,683 @@
+/**
+ @file MeshAlg.h
+
+ Indexed Mesh algorithms.
+
+ @maintainer Morgan McGuire, http://graphics.cs.williams.edu
+
+ @created 2003-09-14
+ @edited 2010-01-18
+*/
+
+#ifndef G3D_MeshAlg_h
+#define G3D_MeshAlg_h
+
+#include "G3D/platform.h"
+#include "G3D/Array.h"
+#include "G3D/Vector3.h"
+#include "G3D/CoordinateFrame.h"
+#include "G3D/SmallArray.h"
+#include "G3D/constants.h"
+#include "G3D/Image1.h"
+
+#ifdef G3D_WIN32
+// Turn off "conditional expression is constant" warning; MSVC generates this
+// for debug assertions in inlined methods.
+#pragma warning (disable : 4127)
+#endif
+
+namespace G3D {
+
+/**
+ Indexed mesh algorithms. You have to build your own mesh class.
+
+ No mesh class is provided with G3D because there isn't an "ideal"
+ mesh format-- one application needs keyframed animation, another
+ skeletal animation, a third texture coordinates, a fourth
+ cannot precompute information, etc. Instead of compromising, this
+ class implements the hard parts of mesh computation and you can write
+ your own ideal mesh class on top of it.
+
+ \sa G3D::ArticulatedModel, G3D::IFSModel
+ */
+class MeshAlg {
+public:
+
+ /** \deprecated */
+ typedef PrimitiveType Primitive;
+
+ /** Adjacency information for a vertex.
+ Does not contain the vertex position or normal,
+ which are stored in the MeshAlg::Geometry object.
+ Vertexs must be stored in an array
+ parallel to (indexed in the same way as)
+ MeshAlg::Geometry::vertexArray.
+ */
+ class Vertex {
+ public:
+ Vertex() {}
+
+ /**
+ Array of edges adjacent to this vertex.
+ Let e = edgeIndex[i].
+ edge[(e >= 0) ? e : ~e].vertexIndex[0] == this
+ vertex index.
+
+ Edges may be listed multiple times if they are
+ degenerate.
+ */
+ SmallArray edgeIndex;
+
+ /**
+ Returns true if e or ~e is in the edgeIndex list.
+ */
+ inline bool inEdge(int e) const {
+ return edgeIndex.contains(~e) || edgeIndex.contains(e);
+ }
+
+ /**
+ Array of faces containing this vertex. Faces
+ may be listed multiple times if they are degenerate.
+ */
+ SmallArray faceIndex;
+
+ inline bool inFace(int f) const {
+ debugAssert(f >= 0);
+ return faceIndex.contains(f);
+ }
+ };
+
+
+ /**
+ Oriented, indexed triangle.
+ */
+ class Face {
+ public:
+ Face();
+
+ /**
+ Used by Edge::faceIndex to indicate a missing face.
+ This is a large negative value.
+ */
+ static const int NONE;
+
+
+ /**
+ Vertices in the face in counter-clockwise order.
+ Degenerate faces may include the same vertex multiple times.
+ */
+ int vertexIndex[3];
+
+ inline bool containsVertex(int v) const {
+ return contains(vertexIndex, 3, v);
+ }
+
+ /**
+ Edge indices in counter-clockwise order. Edges are
+ undirected, so it is important to know which way
+ each edge is pointing in a face. This is encoded
+ using negative indices.
+
+ If edgeIndex[i] >= 0 then this face
+ contains the directed edge
+ between vertex indices
+ edgeArray[face.edgeIndex[i]].vertexIndex[0]
+ and
+ edgeArray[face.edgeIndex[i]].vertexIndex[1].
+
+ If edgeIndex[i] < 0 then
+ ~edgeIndex[i] (i.e. the two's
+ complement of) is used and this face contains the directed
+ edge between vertex indices
+ edgeArray[~face.edgeIndex[i]].vertexIndex[0]
+ and
+ edgeArray[~face.edgeIndex[i]].vertexIndex[1].
+
+ Degenerate faces may include the same edge multiple times.
+ */
+ // Temporarily takes on the value Face::NONE during adjacency
+ // computation to indicate an edge that has not yet been assigned.
+ int edgeIndex[3];
+
+ inline bool containsEdge(int e) const {
+ if (e < 0) {
+ e = ~e;
+ }
+ return contains(edgeIndex, 3, e) || contains(edgeIndex, 3, ~e);
+ }
+
+ /** Contains the forward edge e if e >= 0 and the backward edge
+ ~e otherwise. */
+ inline bool containsDirectedEdge(int e) const {
+ return contains(edgeIndex, 3, e);
+ }
+ };
+
+
+ /** Oriented, indexed edge */
+ class Edge {
+ public:
+ Edge();
+
+ /** Degenerate edges may include the same vertex times. */
+ int vertexIndex[2];
+
+ inline bool containsVertex(int v) const {
+ return contains(vertexIndex, 2, v);
+ }
+
+ /**
+ The edge is directed forward in face 0
+ backward in face 1. Face index of MeshAlg::Face::NONE
+ indicates a boundary (a.k.a. crack, broken) edge.
+ */
+ int faceIndex[2];
+
+ /** Returns true if f is contained in the faceIndex array in either slot.
+ To see if it is forward in that face, just check edge.faceIndex[0] == f.*/
+ inline bool inFace(int f) const {
+ return contains(faceIndex, 2, f);
+ }
+
+ /**
+ Returns true if either faceIndex is NONE.
+ */
+ inline bool boundary() const {
+ return (faceIndex[0] == Face::NONE) ||
+ (faceIndex[1] == Face::NONE);
+ }
+
+ /**
+ Returns the reversed edge.
+ */
+ inline Edge reverse() const {
+ Edge e;
+ e.vertexIndex[0] = vertexIndex[1];
+ e.vertexIndex[1] = vertexIndex[0];
+ e.faceIndex[0] = faceIndex[1];
+ e.faceIndex[1] = faceIndex[0];
+ return e;
+ }
+ };
+
+
+ /**
+ Convenient for passing around the per-vertex data that changes under
+ animation. The faces and edges are needed to interpret
+ these values.
+ */
+ class Geometry {
+ public:
+ /** Vertex positions */
+ Array vertexArray;
+
+ /** Vertex normals */
+ Array normalArray;
+
+ /**
+ Assignment is optimized using SSE.
+ */
+ Geometry& operator=(const Geometry& src);
+
+ void clear() {
+ vertexArray.clear();
+ normalArray.clear();
+ }
+ };
+
+ /**
+ Given a set of vertices and a set of indices for traversing them
+ to create triangles, computes other mesh properties.
+
+