added newest G3D(lite) + VS project files
stripped, but can be stripped more later --HG-- branch : trunk
This commit is contained in:
Rat
+1609
File diff suppressed because it is too large
Load Diff
+281
@@ -0,0 +1,281 @@
|
||||
/**
|
||||
@file AABox.h
|
||||
|
||||
Axis-aligned box class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2004-01-10
|
||||
@edited 2006-02-10
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_AABOX_H
|
||||
#define G3D_AABOX_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/debug.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Plane.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
An axis-aligned box.
|
||||
*/
|
||||
class AABox {
|
||||
private:
|
||||
|
||||
/** Optional argument placeholder */
|
||||
static int dummy;
|
||||
|
||||
Vector3 lo;
|
||||
Vector3 hi;
|
||||
|
||||
public:
|
||||
|
||||
/** Does not initialize the fields */
|
||||
inline AABox() {}
|
||||
|
||||
/**
|
||||
Constructs a zero-area AABox at v.
|
||||
*/
|
||||
inline explicit AABox(const Vector3& v) {
|
||||
lo = hi = v;
|
||||
}
|
||||
|
||||
/** Assumes that low is less than or equal to high along each dimension.
|
||||
To have this automatically enforced, use
|
||||
<code>AABox(low.min(high), low.max(high));</code>
|
||||
*/
|
||||
inline AABox(const Vector3& low, const Vector3& high) {
|
||||
set(low, high);
|
||||
}
|
||||
|
||||
/** Assumes that low is less than or equal to high along each dimension.
|
||||
*/
|
||||
inline void set(const Vector3& low, const Vector3& high) {
|
||||
debugAssert(
|
||||
(low.x <= high.x) &&
|
||||
(low.y <= high.y) &&
|
||||
(low.z <= high.z));
|
||||
lo = low;
|
||||
hi = high;
|
||||
}
|
||||
|
||||
/**
|
||||
Grows to include the bounds of a
|
||||
*/
|
||||
inline void merge(const AABox& a) {
|
||||
lo = lo.min(a.lo);
|
||||
hi = hi.max(a.hi);
|
||||
}
|
||||
|
||||
inline void merge(const Vector3& a) {
|
||||
lo = lo.min(a);
|
||||
hi = hi.max(a);
|
||||
}
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
inline const Vector3& low() const {
|
||||
return lo;
|
||||
}
|
||||
|
||||
inline const Vector3& high() const {
|
||||
return hi;
|
||||
}
|
||||
|
||||
/**
|
||||
The largest possible finite box.
|
||||
*/
|
||||
static inline const AABox& maxFinite() {
|
||||
static const AABox b = AABox(Vector3::minFinite(),
|
||||
Vector3::maxFinite());
|
||||
return b;
|
||||
}
|
||||
|
||||
/** A large finite box. This is smaller than FLT_MAX
|
||||
because it leaves room to add boxes together. */
|
||||
static inline const AABox& large() {
|
||||
static const AABox b = AABox(Vector3::minFinite() * 0.5f,
|
||||
Vector3::maxFinite() * 0.5f);
|
||||
return b;
|
||||
}
|
||||
|
||||
static inline const AABox& inf() {
|
||||
static const AABox b = AABox(-Vector3::inf(), Vector3::inf());
|
||||
return b;
|
||||
}
|
||||
|
||||
static inline const AABox& zero() {
|
||||
static const AABox b = AABox(Vector3::zero(), Vector3::zero());
|
||||
return b;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the centroid of the box.
|
||||
*/
|
||||
inline Vector3 center() const {
|
||||
return (lo + hi) * 0.5;
|
||||
}
|
||||
|
||||
Vector3 corner(int index) const;
|
||||
|
||||
/**
|
||||
Distance from corner(0) to the next corner along axis a.
|
||||
*/
|
||||
inline float extent(int a) const {
|
||||
debugAssert(a < 3);
|
||||
return hi[a] - lo[a];
|
||||
}
|
||||
|
||||
|
||||
inline Vector3 extent() const {
|
||||
return hi - lo;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Splits the box into two AABoxes along the specified axis. low contains
|
||||
the part that was closer to negative infinity along axis, high contains
|
||||
the other part. Either may have zero volume.
|
||||
*/
|
||||
void split(const Vector3::Axis& axis, float location, AABox& low, AABox& high) const;
|
||||
|
||||
/**
|
||||
Conservative culling test for up to 32 planes.
|
||||
Returns true if there exists a <CODE>plane[p]</CODE> for
|
||||
which the entire object is in the negative half space
|
||||
(opposite the plane normal).
|
||||
|
||||
<CODE>testMask</CODE> and <CODE>childMask</CODE>
|
||||
are used for optimizing bounding volume hierarchies.
|
||||
The version of this method that produces childMask
|
||||
is slower than the version without; it should only
|
||||
be used for parent nodes.
|
||||
|
||||
@param cullingPlaneIndex The index of the first plane for which
|
||||
the entire object is in the negative half-space. The function
|
||||
exits early when one plane is found. -1 when the function
|
||||
returns false (i.e. when no plane culls the whole object).
|
||||
|
||||
@param testMask If bit <I>p</I> is 0, the
|
||||
bounding volume automatically passes the culling test for
|
||||
<CODE>plane[p]</CODE> (i.e. it is known that the volume
|
||||
is entirely within the positive half space). The function
|
||||
must return false if testMask is 0 and test all planes
|
||||
when testMask is -1 (0xFFFFFFFF).
|
||||
|
||||
@param childMask Test mask for the children of this volume.
|
||||
|
||||
*/
|
||||
bool culledBy(
|
||||
const Array<Plane>& plane,
|
||||
int32& cullingPlaneIndex,
|
||||
const uint32 testMask,
|
||||
uint32& childMask) const;
|
||||
|
||||
/**
|
||||
Conservative culling test that does not produce a mask for children.
|
||||
*/
|
||||
bool culledBy(
|
||||
const Array<Plane>& plane,
|
||||
int32& cullingPlaneIndex = dummy,
|
||||
const uint32 testMask = 0xFFFFFFFF) const;
|
||||
|
||||
/** less than or equal to containment */
|
||||
inline bool contains(const AABox& other) const {
|
||||
return
|
||||
(other.hi.x <= hi.x) &&
|
||||
(other.hi.y <= hi.y) &&
|
||||
(other.hi.z <= hi.z) &&
|
||||
(other.lo.x >= lo.x) &&
|
||||
(other.lo.y >= lo.y) &&
|
||||
(other.lo.z >= lo.z);
|
||||
}
|
||||
|
||||
inline bool contains(
|
||||
const Vector3& point) const {
|
||||
return
|
||||
(point.x >= lo.x) &&
|
||||
(point.y >= lo.y) &&
|
||||
(point.z >= lo.z) &&
|
||||
(point.x <= hi.x) &&
|
||||
(point.y <= hi.y) &&
|
||||
(point.z <= hi.z);
|
||||
}
|
||||
|
||||
inline float area() const {
|
||||
Vector3 diag = hi - lo;
|
||||
return 2.0f * (diag.x * diag.y + diag.y * diag.z + diag.x * diag.z);
|
||||
}
|
||||
|
||||
inline float volume() const {
|
||||
Vector3 diag = hi - lo;
|
||||
return diag.x * diag.y * diag.z;
|
||||
}
|
||||
|
||||
Vector3 randomInteriorPoint() const;
|
||||
|
||||
Vector3 randomSurfacePoint() const;
|
||||
|
||||
/** Returns true if there is any overlap */
|
||||
bool intersects(const AABox& other) const;
|
||||
|
||||
/** Returns true if there is any overlap.
|
||||
@cite Jim Arvo's algorithm from Graphics Gems II*/
|
||||
bool intersects(const class Sphere& other) const;
|
||||
|
||||
/** Return the intersection of the two boxes */
|
||||
AABox intersect(const AABox& other) const {
|
||||
Vector3 H = hi.min(other.hi);
|
||||
Vector3 L = lo.max(other.lo).min(H);
|
||||
return AABox(L, H);
|
||||
}
|
||||
|
||||
inline size_t hashCode() const {
|
||||
return lo.hashCode() + hi.hashCode();
|
||||
}
|
||||
|
||||
inline bool operator==(const AABox& b) const {
|
||||
return (lo == b.lo) && (hi == b.hi);
|
||||
}
|
||||
|
||||
inline bool operator!=(const AABox& b) const {
|
||||
return !((lo == b.lo) && (hi == b.hi));
|
||||
}
|
||||
|
||||
inline AABox operator+(const Vector3& v) const {
|
||||
AABox out;
|
||||
out.lo = lo + v;
|
||||
out.hi = hi + v;
|
||||
return out;
|
||||
}
|
||||
|
||||
inline AABox operator-(const Vector3& v) const {
|
||||
AABox out;
|
||||
out.lo = lo - v;
|
||||
out.hi = hi - v;
|
||||
return out;
|
||||
}
|
||||
|
||||
void getBounds(AABox& out) const {
|
||||
out = *this;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <> struct HashTrait<G3D::AABox> {
|
||||
static size_t hashCode(const G3D::AABox& key) { return key.hashCode(); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
+506
@@ -0,0 +1,506 @@
|
||||
/**
|
||||
@file AnyVal.h
|
||||
@author Morgan McGuire
|
||||
@created 2006-06-11
|
||||
@edited 2008-07-14
|
||||
*/
|
||||
|
||||
#ifndef G3D_ANYVAL_H
|
||||
#define G3D_ANYVAL_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <string>
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/TextInput.h"
|
||||
|
||||
namespace G3D {
|
||||
// Forward declarations for G3D types
|
||||
class Vector2;
|
||||
class Vector3;
|
||||
class Vector4;
|
||||
class Color1;
|
||||
class Color3;
|
||||
class Color4;
|
||||
class Quat;
|
||||
class Matrix2;
|
||||
class Matrix3;
|
||||
class Matrix4;
|
||||
class CoordinateFrame;
|
||||
class TextInput;
|
||||
class TextOutput;
|
||||
class BinaryInput;
|
||||
class BinaryOutput;
|
||||
class Rect2D;
|
||||
class AABox;
|
||||
|
||||
/**
|
||||
A generic value, useful for defining property trees that can
|
||||
be loaded from and saved to disk. The values are intentionally
|
||||
restricted to a small set.
|
||||
|
||||
When written to files, the syntax is as follows. Note that you can
|
||||
nest arrays and tables in order to create full tree (i.e., XML-like)
|
||||
structures as configuration files:
|
||||
|
||||
<table>
|
||||
<tr><td>NULL</td><td><code>Nil</code></td></tr>
|
||||
<tr><td>double</td><td><i>The number in printf double format</i></td></tr>
|
||||
<tr><td>bool</td><td><code>true</code> <i>or</i> <code>false</code></td></tr>
|
||||
<tr><td>std::string</td><td><i>The string in double-quotes (</i><code>"</code><i>)</i></td></tr>
|
||||
<tr><td>Rect2D</td><td><code>R(</code><i>x<sub>0</sub></i><code>,</code><i>y<sub>0</sub></i><code>,</code><i>x<sub>1</sub></i><code>,</code><i>y<sub>1</sub></i><code>)</code></td></tr>
|
||||
<tr><td>Color1</td><td><code>C1(</code><i>value</i><code>)</code></td></tr>
|
||||
<tr><td>Color3</td><td><code>C3(</code><i>r</i><code>,</code><i>g</i><code>,</code><i>b</i><code>)</code></td></tr>
|
||||
<tr><td>Color4</td><td><code>C4(</code><i>r</i><code>,</code><i>g</i><code>,</code><i>b</i><code>,</code><i>a</i><code>)</code></td></tr>
|
||||
<tr><td>Vector2</td><td><code>V2(</code><i>x</i><code>,</code><i>y</i><code>)</code></td></tr>
|
||||
<tr><td>Vector3</td><td><code>V3(</code><i>x</i><code>,</code><i>y</i><code>,</code><i>z</i><code>)</code></td></tr>
|
||||
<tr><td>Vector4</td><td><code>V4(</code><i>x</i><code>,</code><i>y</i><code>,</code><i>z</i><code>,</code><i>w</i><code>)</code></td></tr>
|
||||
<tr><td>Quat</td><td><code>V(</code>x<code>,</code>y<code>,</code>z<code>,</code>w<code>)</code></td></tr>
|
||||
<tr><td>AABox</td><td><code>AAB(</code>low Vector3<code>, </code>high Vector3<code>)</code></td></tr>
|
||||
<tr><td>Matrix2</td><td><code>M2(</code>r0c0<code>, </code>r0c1<code>,
|
||||
<br> </code>r1c0<code>, </code>r1c1<code>)</code></td></tr>
|
||||
<tr><td>Matrix3</td><td><code>M3(</code>r0c0<code>, </code>r0c1<code>, </code>r0c2<code>,
|
||||
<br> </code>r1c0<code>, </code>r1c1<code>, </code>r1c2<code>,
|
||||
<br> </code>r2c0<code>, </code>r2c1<code>, </code>r2c2<code>)</code></td></tr>
|
||||
<tr><td>Matrix4</td><td><code>M4(</code>r0c0<code>, </code>r0c1<code>, </code>r0c2<code>, </code>r0c3<code>,
|
||||
<br> </code>r1c0<code>, </code>r1c1<code>, </code>r1c2<code>, </code>r1c3<code>,
|
||||
<br> </code>r2c0<code>, </code>r2c1<code>, </code>r2c2<code>, </code>r2c3<code>,
|
||||
<br> </code>r3c0<code>, </code>r3c1<code>, </code>r3c2<code>, </code>r3c3<code>)</code></td></tr>
|
||||
<tr><td>CoordinateFrame</td><td><code>CF(</code>r0c0<code>, </code>r0c1<code>, </code>r0c2<code>, </code>r0c3<code>,
|
||||
<br> </code>r1c0<code>, </code>r1c1<code>, </code>r1c2<code>, </code>r1c3<code>,
|
||||
<br> </code>r2c0<code>, </code>r2c1<code>, </code>r2c2<code>, </code>r2c3<code>)</code></td></tr>
|
||||
<tr><td>CoordinateFrame</td><td><code>CF(V3(</code><i>x</i><code>, </code><i>y</i><code>, </code><i>z</i><code>), </code><i>yaw deg</i><code>, </code><i>pitch deg</i><code>, </code><i>optional roll deg</i><code>)</code></td></tr>
|
||||
|
||||
<tr><td>Array</td><td><code>[</code><i>element<sub>0</sub></i><code>, </code><i>element<sub>1</sub></i><code>, </code> ... <code>, </code><i>element<sub>n-1</sub></i><code>]</code></td></tr>
|
||||
<tr><td>Table</td><td><code>{</code><i>symbol<sub>0</sub></i><code> = </code><i>value<sub>0</sub></i>
|
||||
<br><code> </code><i>symbol<sub>1</sub></i><code> = </code><i>value<sub>1</sub></i>
|
||||
<br><code> </code>...
|
||||
<br><code> </code><i>symbol<sub>n-1</sub></i><code> = </code><i>value<sub>n-1</sub></i><code>}</code></td></tr>
|
||||
</table>
|
||||
|
||||
See also boost::any for a more general purpose but slightly harder to use
|
||||
"any" for C++.
|
||||
|
||||
The semantics of operator[] and the get() methods are slightly different;
|
||||
operator[] acts more like a scripting language that automatically extends
|
||||
arrays and tables instead of generating errors. get() has more strict semantics,
|
||||
like a C++ class.
|
||||
|
||||
AnyVal uses copy-on-mutate, so that <code>AnyVal a = b</code> semantically copies <code>b</code> (like <code>int a = b</code> would), although in practice
|
||||
it delays the copy until one is mutated so that it is still fast to "copy" large arrays and tables.
|
||||
|
||||
Reading example:
|
||||
<pre>
|
||||
AnyVal property = AnyVal::fromFile("c:/tmp/test.txt"));
|
||||
|
||||
Vector3 vel = property["angular velocity"]
|
||||
|
||||
<i>Using defaults to handle errors:
|
||||
If there was no "enabled" value, this will return the default instead of failing</i>
|
||||
bool enabled = property["enabled"].boolean(true);
|
||||
|
||||
</pre>
|
||||
|
||||
Writing to a file:
|
||||
<pre>
|
||||
AnyVal dict(AnyVal::TABLE);
|
||||
|
||||
dict["enabled"] = AnyVal(true);
|
||||
dict["weight"] = 100;
|
||||
dict["angular velocity"] = Vector3(1, -3, 4.5);
|
||||
|
||||
TextOutput t("c:/tmp/test.txt");
|
||||
dict.serialize(t);
|
||||
t.commit();
|
||||
</pre>
|
||||
|
||||
Example of a data file:
|
||||
<pre>
|
||||
{
|
||||
heights = [1, 17, 32]
|
||||
model =
|
||||
{
|
||||
color = C3(1, 1, 1)
|
||||
filename = "foo.md2"
|
||||
}
|
||||
position = V3(23, 14, 0)
|
||||
name = "Elmer"
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
<b>What's the difference from boost::any?</b>
|
||||
<br>I think that AnyVal will be easier for novice C++ users. It addresses the problem that
|
||||
even though G3D::TextInput makes reading configuration files extremely simple, many people
|
||||
still don't use it. So AnyVal makes it ridiculously simple to read and write a tree of G3D
|
||||
types to a file.
|
||||
|
||||
<i>AnyVal:</i>
|
||||
<pre>
|
||||
{
|
||||
AnyVal tree(TextInput("config.txt"));
|
||||
|
||||
bool enabled = tree.get("enabled", false);
|
||||
Vector3 direction = tree.get("direction", Vector3::zero());
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
|
||||
<i>boost:</i>
|
||||
<pre>
|
||||
{
|
||||
bool enabled = false;
|
||||
Vector3 direction;
|
||||
Table<boost::any> tree;
|
||||
|
||||
...write lots of file parsing code...
|
||||
|
||||
if (tree.containsKey("enabled")) {
|
||||
const boost::any& val = tree["enabled"];
|
||||
try {
|
||||
enabled = any_cast<bool>(val);
|
||||
} catch(const boost::bad_any_cast &) {
|
||||
}
|
||||
}
|
||||
|
||||
if (tree.containsKey("direction")) {
|
||||
const boost::any& val = tree["direction"];
|
||||
try {
|
||||
direction = any_cast<Vector3>(val);
|
||||
} catch(const boost::bad_any_cast &) {
|
||||
}
|
||||
}
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
*/
|
||||
class AnyVal {
|
||||
public:
|
||||
|
||||
/** Array and table values are all Any.*/
|
||||
enum Type {
|
||||
NIL,
|
||||
NUMBER,
|
||||
BOOLEAN,
|
||||
STRING,
|
||||
VECTOR2,
|
||||
VECTOR3,
|
||||
VECTOR4,
|
||||
MATRIX2,
|
||||
MATRIX3,
|
||||
MATRIX4,
|
||||
QUAT,
|
||||
COORDINATEFRAME,
|
||||
COORDINATEFRAME2D,
|
||||
CFRAME = COORDINATEFRAME,
|
||||
CFRAME2D = COORDINATEFRAME2D,
|
||||
COLOR1,
|
||||
COLOR3,
|
||||
COLOR4,
|
||||
RECT2D,
|
||||
AABOX2D = RECT2D,
|
||||
AABOX,
|
||||
ARRAY,
|
||||
TABLE};
|
||||
|
||||
/** Base class for all AnyVal exceptions.*/
|
||||
class Exception {
|
||||
public:
|
||||
virtual ~Exception() {}
|
||||
};
|
||||
|
||||
/** Thrown when an inappropriate operation is performed (e.g., operator[] on a number) */
|
||||
class WrongType : public Exception {
|
||||
public:
|
||||
Type expected;
|
||||
Type actual;
|
||||
WrongType() : expected(NIL), actual(NIL) {}
|
||||
WrongType(Type e, Type a) : expected(e), actual(a) {}
|
||||
};
|
||||
|
||||
/** Thrown by operator[] when a key is not present. */
|
||||
class KeyNotFound : public Exception {
|
||||
public:
|
||||
std::string key;
|
||||
KeyNotFound() {}
|
||||
KeyNotFound(const std::string& k) : key(k) {}
|
||||
};
|
||||
|
||||
class IndexOutOfBounds : public Exception {
|
||||
public:
|
||||
int index;
|
||||
int size;
|
||||
IndexOutOfBounds() : index(0), size(0) {}
|
||||
IndexOutOfBounds(int i, int s) : index(i), size(s) {}
|
||||
};
|
||||
|
||||
/** Thrown when deserialize() when the input is incorrectly formatted. */
|
||||
class CorruptText : public Exception {
|
||||
public:
|
||||
std::string message;
|
||||
|
||||
/** Token where the problem occurred.*/
|
||||
G3D::Token token;
|
||||
|
||||
CorruptText() {}
|
||||
CorruptText(const std::string& s, const G3D::Token& t) : message(s), token(t) {}
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
Type m_type;
|
||||
void* m_value;
|
||||
|
||||
/** For table and array types, *m_value is shared between multiple
|
||||
instances. Mutation is allowed only if the reference count is
|
||||
exactly 1, otherwise the mutating instance must copy the
|
||||
value. This is not used for other types.
|
||||
*/
|
||||
int* m_referenceCount;
|
||||
|
||||
/** Decrements the reference count (if there is one). If the
|
||||
reference count is zero or does not exist. Calls delete on @a
|
||||
m_value and sets it to NULL.
|
||||
*/
|
||||
void deleteValue();
|
||||
|
||||
/** Returns a copy of the value. */
|
||||
void* copyValue() const;
|
||||
|
||||
/** Assumes isSharedType. Ensures that this has a unique reference */
|
||||
void makeMutable();
|
||||
|
||||
/** True if this is a shared value between multiple instances. */
|
||||
inline bool isShared() const {
|
||||
return m_referenceCount && (*m_referenceCount > 1);
|
||||
}
|
||||
|
||||
/** True when m_value is a double pointer */
|
||||
inline bool isSharedType() const {
|
||||
return (m_type == TABLE) || (m_type == ARRAY);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
AnyVal();
|
||||
|
||||
/** Deserialize */
|
||||
explicit AnyVal(G3D::TextInput& t);
|
||||
|
||||
static AnyVal fromFile(const std::string& filename);
|
||||
|
||||
void load(const std::string& filename);
|
||||
|
||||
void save(const std::string& filename) const;
|
||||
|
||||
///** Deserialize */
|
||||
//explicit AnyVal(G3D::BinaryInput& t);
|
||||
|
||||
/** Construct a number */
|
||||
AnyVal(double);
|
||||
AnyVal(int);
|
||||
|
||||
// Explicit to avoid ambiguity with the 'double' constructor
|
||||
// when an integer type is constructed
|
||||
AnyVal(bool);
|
||||
AnyVal(const G3D::Vector2&);
|
||||
AnyVal(const G3D::Vector3&);
|
||||
AnyVal(const G3D::Vector4&);
|
||||
|
||||
AnyVal(const G3D::Color1&);
|
||||
AnyVal(const G3D::Color3&);
|
||||
AnyVal(const G3D::Color4&);
|
||||
|
||||
AnyVal(const std::string&);
|
||||
AnyVal(const char*);
|
||||
|
||||
AnyVal(const G3D::Quat&);
|
||||
|
||||
AnyVal(const G3D::Rect2D&);
|
||||
AnyVal(const G3D::AABox&);
|
||||
|
||||
AnyVal(const G3D::CoordinateFrame&);
|
||||
AnyVal(const G3D::Matrix2&);
|
||||
AnyVal(const G3D::Matrix3&);
|
||||
AnyVal(const G3D::Matrix4&);
|
||||
|
||||
AnyVal(const AnyVal&);
|
||||
|
||||
AnyVal(Type arrayOrTable);
|
||||
|
||||
AnyVal& operator=(const AnyVal&);
|
||||
|
||||
/** Frees the underlying storage */
|
||||
~AnyVal();
|
||||
|
||||
Type type() const;
|
||||
|
||||
bool isNil() const {
|
||||
return type() == NIL;
|
||||
}
|
||||
|
||||
void serialize(G3D::TextOutput& t) const;
|
||||
//void serialize(G3D::BinaryOutput& t) const;
|
||||
void deserialize(G3D::TextInput& t);
|
||||
//void deserialize(G3D::BinaryInput& t);
|
||||
|
||||
/** Array dereference. If the index is out of bounds, IndexOutOfBounds is thrown */
|
||||
const AnyVal& operator[](int) const;
|
||||
|
||||
/** Extend this array by one element. */
|
||||
void append(const AnyVal&);
|
||||
|
||||
/** If the index is out of bounds, the array is resized. If the index is negative,
|
||||
IndexOutOfBounds is thrown.*/
|
||||
AnyVal& operator[](int);
|
||||
|
||||
/** If @a i is out of bounds or this is not an ARRAY, defaultVal is returned.*/
|
||||
const AnyVal& get(int i, const AnyVal& defaultVal) const;
|
||||
|
||||
/** If out of bounds, IndexOutOfBounds is thrown. */
|
||||
const AnyVal& get(int i) const;
|
||||
|
||||
/** Returns defaultVal if this is not a TABLE or the key is not found. */
|
||||
const AnyVal& get(const std::string& key, const AnyVal& defaultVal) const;
|
||||
|
||||
/** Throws KeyNotFound exception if the key is not present.*/
|
||||
const AnyVal& get(const std::string& key) const;
|
||||
|
||||
/** Table reference */
|
||||
const AnyVal& operator[](const std::string&) const;
|
||||
|
||||
/** Table reference. If the element does not exist, it is created. */
|
||||
AnyVal& operator[](const std::string&);
|
||||
|
||||
/** Table reference */
|
||||
const AnyVal& operator[](const char*) const;
|
||||
|
||||
/** Table reference. If the element does not exist, it is created. */
|
||||
AnyVal& operator[](const char*);
|
||||
|
||||
/** If this value is not a number throws a WrongType exception. */
|
||||
double number() const;
|
||||
|
||||
/** If this value is not a number, returns defaultVal. */
|
||||
double number(double defaultVal) const;
|
||||
|
||||
operator double () const {
|
||||
return number();
|
||||
}
|
||||
|
||||
operator float () const {
|
||||
return (float)number();
|
||||
}
|
||||
|
||||
bool boolean() const;
|
||||
bool boolean(bool b) const;
|
||||
|
||||
operator bool() const {
|
||||
return boolean();
|
||||
}
|
||||
|
||||
const std::string& string() const;
|
||||
const std::string& string(const std::string& defaultVal) const;
|
||||
|
||||
operator const std::string& () const {
|
||||
return string();
|
||||
}
|
||||
|
||||
const G3D::Rect2D& rect2D() const;
|
||||
const G3D::Rect2D& rect2D(const G3D::Rect2D& defaultVal) const;
|
||||
|
||||
operator const Rect2D& () const {
|
||||
return rect2D();
|
||||
}
|
||||
|
||||
const G3D::AABox& aabox() const;
|
||||
const G3D::AABox& aabox(const G3D::AABox& defaultVal) const;
|
||||
|
||||
operator const AABox& () const {
|
||||
return aabox();
|
||||
}
|
||||
|
||||
const G3D::Vector2& vector2() const;
|
||||
const G3D::Vector2& vector2(const G3D::Vector2& defaultVal) const;
|
||||
|
||||
operator const Vector2& () const {
|
||||
return vector2();
|
||||
}
|
||||
|
||||
const G3D::Vector3& vector3() const;
|
||||
const G3D::Vector3& vector3(const G3D::Vector3& defaultVal) const;
|
||||
|
||||
operator const Vector3& () {
|
||||
return vector3();
|
||||
}
|
||||
|
||||
const G3D::Vector4& vector4() const;
|
||||
const G3D::Vector4& vector4(const G3D::Vector4& defaultVal) const;
|
||||
|
||||
operator const Vector4& () const {
|
||||
return vector4();
|
||||
}
|
||||
|
||||
const G3D::Color1& color1() const;
|
||||
const G3D::Color1& color1(const G3D::Color1& defaultVal) const;
|
||||
|
||||
const G3D::Color3& color3() const;
|
||||
const G3D::Color3& color3(const G3D::Color3& defaultVal) const;
|
||||
|
||||
operator const Color3& () const {
|
||||
return color3();
|
||||
}
|
||||
|
||||
const G3D::Color4& color4() const;
|
||||
const G3D::Color4& color4(const G3D::Color4& defaultVal) const;
|
||||
|
||||
operator const Color4& () const {
|
||||
return color4();
|
||||
}
|
||||
|
||||
const G3D::CoordinateFrame& coordinateFrame() const;
|
||||
const G3D::CoordinateFrame& coordinateFrame(const G3D::CoordinateFrame& defaultVal) const;
|
||||
|
||||
operator const CoordinateFrame& () const {
|
||||
return coordinateFrame();
|
||||
}
|
||||
|
||||
const G3D::Matrix2& matrix2() const;
|
||||
const G3D::Matrix2& matrix2(const G3D::Matrix2& defaultVal) const;
|
||||
|
||||
operator const Matrix2& () const {
|
||||
return matrix2();
|
||||
}
|
||||
|
||||
const G3D::Matrix3& matrix3() const;
|
||||
const G3D::Matrix3& matrix3(const G3D::Matrix3& defaultVal) const;
|
||||
|
||||
operator const Matrix3& () const {
|
||||
return matrix3();
|
||||
}
|
||||
|
||||
const G3D::Matrix4& matrix4() const;
|
||||
const G3D::Matrix4& matrix4(const G3D::Matrix4& defaultVal) const;
|
||||
|
||||
operator const Matrix4& () const {
|
||||
return matrix4();
|
||||
}
|
||||
|
||||
const G3D::Quat& quat() const;
|
||||
const G3D::Quat& quat(const G3D::Quat& defaultVal) const;
|
||||
|
||||
operator const Quat& () const {
|
||||
return quat();
|
||||
}
|
||||
|
||||
std::string toString() const;
|
||||
|
||||
/** Number of elements for an array or table.*/
|
||||
int size() const;
|
||||
|
||||
/** For a table, returns the keys. */
|
||||
void getKeys(G3D::Array<std::string>&) const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+1180
File diff suppressed because it is too large
Load Diff
+166
@@ -0,0 +1,166 @@
|
||||
/**
|
||||
@file AtomicInt32.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2005-09-01
|
||||
@edited 2006-06-21
|
||||
*/
|
||||
#ifndef G3D_ATOMICINT32_H
|
||||
#define G3D_ATOMICINT32_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
#if defined(G3D_OSX)
|
||||
#include <libkern/OSAtomic.h>
|
||||
#endif
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
An integer that may safely be used on different threads without
|
||||
external locking.
|
||||
|
||||
On Win32, Linux, FreeBSD, and Mac OS X this is implemented without locks.
|
||||
|
||||
<B>BETA API</B> This is unsupported and may change
|
||||
*/
|
||||
class AtomicInt32 {
|
||||
private:
|
||||
# if defined(G3D_WIN32)
|
||||
volatile long m_value;
|
||||
# elif defined(G3D_OSX)
|
||||
int32_t m_value;
|
||||
# else
|
||||
volatile int32 m_value;
|
||||
# endif
|
||||
|
||||
|
||||
public:
|
||||
|
||||
/** Initial value is undefined. */
|
||||
AtomicInt32() {}
|
||||
|
||||
/** Atomic set */
|
||||
explicit AtomicInt32(const int32 x) {
|
||||
m_value = x;
|
||||
}
|
||||
|
||||
/** Atomic set */
|
||||
AtomicInt32(const AtomicInt32& x) {
|
||||
m_value = x.m_value;
|
||||
}
|
||||
|
||||
/** Atomic set */
|
||||
const AtomicInt32& operator=(const int32 x) {
|
||||
m_value = x;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** Atomic set */
|
||||
void operator=(const AtomicInt32& x) {
|
||||
m_value = x.m_value;
|
||||
}
|
||||
|
||||
/** Returns the current value */
|
||||
int32 value() const {
|
||||
return m_value;
|
||||
}
|
||||
|
||||
/** Returns the old value, before the add. */
|
||||
int32 add(const int32 x) {
|
||||
# if defined(G3D_WIN32)
|
||||
|
||||
return InterlockedExchangeAdd(&m_value, x);
|
||||
|
||||
# elif defined(G3D_LINUX) || defined(G3D_FREEBSD)
|
||||
|
||||
int32 old;
|
||||
asm volatile ("lock; xaddl %0,%1"
|
||||
: "=r"(old), "=m"(m_value) /* outputs */
|
||||
: "0"(x), "m"(m_value) /* inputs */
|
||||
: "memory", "cc");
|
||||
return old;
|
||||
|
||||
# elif defined(G3D_OSX)
|
||||
|
||||
int32 old = m_value;
|
||||
OSAtomicAdd32(x, &m_value);
|
||||
return old;
|
||||
|
||||
# endif
|
||||
}
|
||||
|
||||
/** Returns old value. */
|
||||
int32 sub(const int32 x) {
|
||||
return add(-x);
|
||||
}
|
||||
|
||||
void increment() {
|
||||
# if defined(G3D_WIN32)
|
||||
// Note: returns the newly incremented value
|
||||
InterlockedIncrement(&m_value);
|
||||
# elif defined(G3D_LINUX) || defined(G3D_FREEBSD)
|
||||
add(1);
|
||||
# elif defined(G3D_OSX)
|
||||
// Note: returns the newly incremented value
|
||||
OSAtomicIncrement32(&m_value);
|
||||
# endif
|
||||
}
|
||||
|
||||
/** Returns zero if the result is zero after decrement, non-zero otherwise.*/
|
||||
int32 decrement() {
|
||||
# if defined(G3D_WIN32)
|
||||
// Note: returns the newly decremented value
|
||||
return InterlockedDecrement(&m_value);
|
||||
# elif defined(G3D_LINUX) || defined(G3D_FREEBSD)
|
||||
unsigned char nz;
|
||||
|
||||
asm volatile ("lock; decl %1;\n\t"
|
||||
"setnz %%al"
|
||||
: "=a" (nz)
|
||||
: "m" (m_value)
|
||||
: "memory", "cc");
|
||||
return nz;
|
||||
# elif defined(G3D_OSX)
|
||||
// Note: returns the newly decremented value
|
||||
return OSAtomicDecrement32(&m_value);
|
||||
# endif
|
||||
}
|
||||
|
||||
|
||||
/** Atomic test-and-set: if <code>*this == comperand</code> then <code>*this := exchange</code> else do nothing.
|
||||
In both cases, returns the old value of <code>*this</code>.
|
||||
|
||||
Performs an atomic comparison of this with the Comperand value.
|
||||
If this is equal to the Comperand value, the Exchange value is stored in this.
|
||||
Otherwise, no operation is performed.
|
||||
|
||||
Under VC6 the sign bit may be lost.
|
||||
|
||||
*/
|
||||
int32 compareAndSet(const int32 comperand, const int32 exchange) {
|
||||
# if defined(G3D_WIN32)
|
||||
return InterlockedCompareExchange(&m_value, exchange, comperand);
|
||||
# elif defined(G3D_LINUX) || defined(G3D_FREEBSD)
|
||||
int32 ret;
|
||||
asm volatile ("lock; cmpxchgl %1, %2"
|
||||
: "=a" (ret)
|
||||
: "r" (exchange), "m" (m_value), "0"(comperand)
|
||||
: "memory", "cc");
|
||||
return ret;
|
||||
# elif defined(G3D_OSX)
|
||||
int32 old = m_value;
|
||||
|
||||
OSAtomicCompareAndSwap32(comperand, exchange, &m_value);
|
||||
|
||||
return old;
|
||||
# endif
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,140 @@
|
||||
/**
|
||||
@file BinaryFormat.h
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@author 2005-06-03
|
||||
@edited 2005-06-03
|
||||
|
||||
Copyright 2000-2005, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_BINARYFORMAT_H
|
||||
#define G3D_BINARYFORMAT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class Vector2;
|
||||
class Vector2int16;
|
||||
class Vector3;
|
||||
class Vector3int16;
|
||||
class Vector4;
|
||||
class Vector4int16;
|
||||
class Color3;
|
||||
class Color3uint8;
|
||||
class Color4;
|
||||
class Color4uint8;
|
||||
|
||||
/**
|
||||
Some values like float16 and int128 have no current CPU data structure that implements them but are useful
|
||||
for file formats and for GPUs.
|
||||
|
||||
CHUNK_BINFMT data follows the protocol.
|
||||
*/
|
||||
// Must be packed int 16 bits for the chunk reader
|
||||
// We can't name these just "INT8" etc. because some libraries #define names like that
|
||||
enum BinaryFormat {
|
||||
FIRST_BINFMT = 1000,
|
||||
|
||||
BOOL8_BINFMT,
|
||||
UINT8_BINFMT, INT8_BINFMT, UINT16_BINFMT, INT16_BINFMT, UINT32_BINFMT, INT32_BINFMT, UINT64_BINFMT, INT64_BINFMT, UINT128_BINFMT, INT128_BINFMT,
|
||||
FLOAT16_BINFMT, FLOAT32_BINFMT, FLOAT64_BINFMT,
|
||||
VECTOR2_BINFMT, VECTOR2INT16_BINFMT,
|
||||
VECTOR3_BINFMT, VECTOR3INT16_BINFMT,
|
||||
VECTOR4_BINFMT, VECTOR4INT16_BINFMT,
|
||||
COLOR3_BINFMT, COLOR3UINT8_BINFMT, COLOR3INT16_BINFMT,
|
||||
COLOR4_BINFMT, COLOR4UINT8_BINFMT, COLOR4INT16_BINFMT,
|
||||
STRING_BINFMT, STRINGEVEN_BINFMT, STRING8_BINFMT, STRING16_BINFMT, STRING32_BINFMT,
|
||||
|
||||
CHUNK_BINFMT,
|
||||
|
||||
CUSTOM_BINFMT,
|
||||
|
||||
LAST_BINFMT
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
/** A macro that maps G3D types to format constants.
|
||||
(e.g. binaryFormatOf(Vector3) == VECTOR3_BINFMT).
|
||||
*/
|
||||
// This implementation is designed to meet the following constraints:
|
||||
// 1. Work around the many MSVC++ partial template bugs
|
||||
// 2. Work for primitive types (e.g. int)
|
||||
#define binaryFormatOf(T) (G3D::_internal::_BinaryFormat<T>::x())
|
||||
|
||||
namespace G3D {
|
||||
namespace _internal {
|
||||
|
||||
|
||||
template<class T> class _BinaryFormat {
|
||||
public:
|
||||
static BinaryFormat x() {
|
||||
return CUSTOM_BINFMT;
|
||||
}
|
||||
};
|
||||
}}
|
||||
|
||||
|
||||
/**
|
||||
Macro to declare the underlying format (as will be returned by glFormatOf)
|
||||
of a type. For example,
|
||||
|
||||
<PRE>
|
||||
DECLARE_BINARYFORMATOF(Vector4, VECTOR4_BINFMT)
|
||||
</PRE>
|
||||
|
||||
Use this so you can make vertex arrays of your own classes and not just
|
||||
the standard ones.
|
||||
*/
|
||||
#define DECLARE_BINARYFORMATOF(CType, EnumType) \
|
||||
namespace G3D { \
|
||||
namespace _internal { \
|
||||
template<> class _BinaryFormat<CType> { \
|
||||
public: \
|
||||
static BinaryFormat x() { \
|
||||
return EnumType; \
|
||||
} \
|
||||
}; \
|
||||
} \
|
||||
}
|
||||
|
||||
DECLARE_BINARYFORMATOF( bool, BOOL8_BINFMT )
|
||||
|
||||
DECLARE_BINARYFORMATOF( uint8, UINT8_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( int8, INT8_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( uint16, UINT16_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( int16, INT16_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( uint32, UINT32_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( int32, INT32_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( uint64, UINT64_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( int64, INT64_BINFMT )
|
||||
|
||||
DECLARE_BINARYFORMATOF( float32, FLOAT32_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( float64, FLOAT64_BINFMT )
|
||||
|
||||
DECLARE_BINARYFORMATOF( Vector2, VECTOR2_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Vector2int16, VECTOR2INT16_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Vector3, VECTOR3_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Vector3int16, VECTOR3INT16_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Vector4, VECTOR4_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Vector4int16, VECTOR4INT16_BINFMT )
|
||||
|
||||
DECLARE_BINARYFORMATOF( Color3, COLOR3_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Color3uint8, COLOR3UINT8_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Color4, COLOR4_BINFMT )
|
||||
DECLARE_BINARYFORMATOF( Color4uint8, COLOR4UINT8_BINFMT )
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/** Returns -1 if the format is custom, otherwise the byte size
|
||||
of a single element in this format.*/
|
||||
int32 byteSize(BinaryFormat f);
|
||||
|
||||
|
||||
} //G3D
|
||||
|
||||
#endif
|
||||
+441
@@ -0,0 +1,441 @@
|
||||
/**
|
||||
@file BinaryInput.h
|
||||
|
||||
@maintainer Morgan McGuire, graphics3d.com
|
||||
|
||||
@created 2001-08-09
|
||||
@edited 2006-07-19
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_BINARYINPUT_H
|
||||
#define G3D_BINARYINPUT_H
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// Disable conditional expression is constant, which occurs incorrectly on inlined functions
|
||||
# pragma warning(push)
|
||||
# pragma warning( disable : 4127 )
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Color4.h"
|
||||
#include "G3D/Color3.h"
|
||||
#include "G3D/Vector4.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector2.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/debug.h"
|
||||
#include "G3D/System.h"
|
||||
|
||||
|
||||
namespace G3D {
|
||||
|
||||
#if defined(G3D_WIN32) || defined(G3D_LINUX)
|
||||
// Allow writing of integers to non-word aligned locations.
|
||||
// This is legal on x86, but not on other platforms.
|
||||
#define G3D_ALLOW_UNALIGNED_WRITES
|
||||
#endif
|
||||
|
||||
/**
|
||||
Sequential or random access byte-order independent binary file access.
|
||||
Files compressed with zlib and beginning with an unsigned 32-bit int
|
||||
size are transparently decompressed when the compressed = true flag is
|
||||
specified to the constructor.
|
||||
|
||||
For every readX method there are also versions that operate on a whole
|
||||
Array, std::vector, or C-array. e.g. readFloat32(Array<float32>& array, n)
|
||||
These methods resize the array or std::vector to the appropriate size
|
||||
before reading. For a C-array, they require the pointer to reference
|
||||
a memory block at least large enough to hold <I>n</I> elements.
|
||||
|
||||
Most classes define serialize/deserialize methods that use BinaryInput,
|
||||
BinaryOutput, TextInput, and TextOutput. There are text serializer
|
||||
functions for primitive types (e.g. int, std::string, float, double) but not
|
||||
binary serializers-- you <B>must</b> call the BinaryInput::readInt32 or
|
||||
other appropriate function. This is because it would be very hard to
|
||||
debug the error sequence: <CODE>serialize(1.0, bo); ... float f; deserialize(f, bi);</CODE>
|
||||
in which a double is serialized and then deserialized as a float.
|
||||
*/
|
||||
class BinaryInput {
|
||||
private:
|
||||
|
||||
// The initial buffer will be no larger than this, but
|
||||
// may grow if a large memory read occurs. 50 MB
|
||||
enum {INITIAL_BUFFER_LENGTH = 50000000};
|
||||
|
||||
/**
|
||||
is the file big or little endian
|
||||
*/
|
||||
G3DEndian m_fileEndian;
|
||||
std::string m_filename;
|
||||
|
||||
bool m_swapBytes;
|
||||
|
||||
/** Next position to read from in bitString during readBits. */
|
||||
int m_bitPos;
|
||||
|
||||
/** Bits currently being read by readBits.
|
||||
Contains at most 8 (low) bits. Note that
|
||||
beginBits/readBits actually consumes one extra byte, which
|
||||
will be restored by writeBits.*/
|
||||
uint32 m_bitString;
|
||||
|
||||
/** 1 when between beginBits and endBits, 0 otherwise. */
|
||||
int m_beginEndBits;
|
||||
|
||||
/** When operating on huge files, we cannot load the whole file into memory.
|
||||
This is the file position to which buffer[0] corresponds.
|
||||
*/
|
||||
int64 m_alreadyRead;
|
||||
|
||||
/**
|
||||
Length of the entire file, in bytes.
|
||||
For the length of the buffer, see bufferLength
|
||||
*/
|
||||
int64 m_length;
|
||||
|
||||
/** Length of the array referenced by buffer. May go past the end of the file!*/
|
||||
int64 m_bufferLength;
|
||||
uint8* m_buffer;
|
||||
|
||||
/**
|
||||
Next byte in file, relative to buffer.
|
||||
*/
|
||||
int64 m_pos;
|
||||
|
||||
/**
|
||||
When true, the buffer is freed in the destructor.
|
||||
*/
|
||||
bool m_freeBuffer;
|
||||
|
||||
/** Ensures that we are able to read at least minLength from startPosition (relative
|
||||
to start of file). */
|
||||
void loadIntoMemory(int64 startPosition, int64 minLength = 0);
|
||||
|
||||
/** Verifies that at least this number of bytes can be read.*/
|
||||
inline void prepareToRead(int64 nbytes) {
|
||||
debugAssertM(m_length > 0, m_filename + " not found or corrupt.");
|
||||
debugAssertM(m_pos + nbytes + m_alreadyRead <= m_length, "Read past end of file.");
|
||||
|
||||
if (m_pos + nbytes > m_bufferLength) {
|
||||
loadIntoMemory(m_pos + m_alreadyRead, nbytes);
|
||||
}
|
||||
}
|
||||
|
||||
// Not implemented on purpose, don't use
|
||||
BinaryInput(const BinaryInput&);
|
||||
BinaryInput& operator=(const BinaryInput&);
|
||||
bool operator==(const BinaryInput&);
|
||||
|
||||
/** Buffer is compressed; replace it with a decompressed version */
|
||||
void decompress();
|
||||
public:
|
||||
|
||||
/** false, constant to use with the copyMemory option */
|
||||
static const bool NO_COPY;
|
||||
|
||||
/**
|
||||
If the file cannot be opened, a zero length buffer is presented.
|
||||
Automatically opens files that are inside zipfiles.
|
||||
|
||||
@param compressed Set to true if and only if the file was
|
||||
compressed using BinaryOutput's zlib compression. This has
|
||||
nothing to do with whether the input is in a zipfile.
|
||||
*/
|
||||
BinaryInput(
|
||||
const std::string& filename,
|
||||
G3DEndian fileEndian,
|
||||
bool compressed = false);
|
||||
|
||||
/**
|
||||
Creates input stream from an in memory source.
|
||||
Unless you specify copyMemory = false, the data is copied
|
||||
from the pointer, so you may deallocate it as soon as the
|
||||
object is constructed. It is an error to specify copyMemory = false
|
||||
and compressed = true.
|
||||
|
||||
To decompress part of a file, you can follow the following paradigm:
|
||||
|
||||
<PRE>
|
||||
BinaryInput master(...);
|
||||
|
||||
// read from master to point where compressed data exists.
|
||||
|
||||
BinaryInput subset(master.getCArray() + master.getPosition(),
|
||||
master.length() - master.getPosition(),
|
||||
master.endian(), true, true);
|
||||
|
||||
// Now read from subset (it is ok for master to go out of scope)
|
||||
</PRE>
|
||||
*/
|
||||
BinaryInput(
|
||||
const uint8* data,
|
||||
int64 dataLen,
|
||||
G3DEndian dataEndian,
|
||||
bool compressed = false,
|
||||
bool copyMemory = true);
|
||||
|
||||
virtual ~BinaryInput();
|
||||
|
||||
/** Change the endian-ness of the file. This only changes the
|
||||
interpretation of the file for future read calls; the
|
||||
underlying data is unmodified.*/
|
||||
void setEndian(G3DEndian endian);
|
||||
|
||||
G3DEndian endian() const {
|
||||
return m_fileEndian;
|
||||
}
|
||||
|
||||
std::string getFilename() const {
|
||||
return m_filename;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a pointer to the internal memory buffer.
|
||||
May throw an exception for huge files.
|
||||
*/
|
||||
const uint8* getCArray() const {
|
||||
if (m_alreadyRead > 0) {
|
||||
throw "Cannot getCArray for a huge file";
|
||||
}
|
||||
return m_buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
Performs bounds checks in debug mode. [] are relative to
|
||||
the start of the file, not the current position.
|
||||
Seeks to the new position before reading (and leaves
|
||||
that as the current position)
|
||||
*/
|
||||
inline uint8 operator[](int64 n) {
|
||||
setPosition(n);
|
||||
return readUInt8();
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the length of the file in bytes.
|
||||
*/
|
||||
inline int64 getLength() const {
|
||||
return m_length;
|
||||
}
|
||||
|
||||
inline int64 size() const {
|
||||
return getLength();
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the current byte position in the file,
|
||||
where 0 is the beginning and getLength() - 1 is the end.
|
||||
*/
|
||||
inline int64 getPosition() const {
|
||||
return m_pos + m_alreadyRead;
|
||||
}
|
||||
|
||||
/**
|
||||
Sets the position. Cannot set past length.
|
||||
May throw a char* when seeking backwards more than 10 MB on a huge file.
|
||||
*/
|
||||
inline void setPosition(int64 p) {
|
||||
debugAssertM(p <= m_length, "Read past end of file");
|
||||
m_pos = p - m_alreadyRead;
|
||||
if ((m_pos < 0) || (m_pos > m_bufferLength)) {
|
||||
loadIntoMemory(m_pos + m_alreadyRead);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Goes back to the beginning of the file.
|
||||
*/
|
||||
inline void reset() {
|
||||
setPosition(0);
|
||||
}
|
||||
|
||||
inline int8 readInt8() {
|
||||
prepareToRead(1);
|
||||
return m_buffer[m_pos++];
|
||||
}
|
||||
|
||||
inline bool readBool8() {
|
||||
return (readInt8() != 0);
|
||||
}
|
||||
|
||||
inline uint8 readUInt8() {
|
||||
prepareToRead(1);
|
||||
return ((uint8*)m_buffer)[m_pos++];
|
||||
}
|
||||
|
||||
uint16 inline readUInt16() {
|
||||
prepareToRead(2);
|
||||
|
||||
m_pos += 2;
|
||||
if (m_swapBytes) {
|
||||
uint8 out[2];
|
||||
out[0] = m_buffer[m_pos - 1];
|
||||
out[1] = m_buffer[m_pos - 2];
|
||||
return *(uint16*)out;
|
||||
} else {
|
||||
#ifdef G3D_ALLOW_UNALIGNED_WRITES
|
||||
return *(uint16*)(&m_buffer[m_pos - 2]);
|
||||
#else
|
||||
uint8 out[2];
|
||||
out[0] = m_buffer[m_pos - 2];
|
||||
out[1] = m_buffer[m_pos - 1];
|
||||
return *(uint16*)out;
|
||||
#endif
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
inline int16 readInt16() {
|
||||
uint16 a = readUInt16();
|
||||
return *(int16*)&a;
|
||||
}
|
||||
|
||||
inline uint32 readUInt32() {
|
||||
prepareToRead(4);
|
||||
|
||||
m_pos += 4;
|
||||
if (m_swapBytes) {
|
||||
uint8 out[4];
|
||||
out[0] = m_buffer[m_pos - 1];
|
||||
out[1] = m_buffer[m_pos - 2];
|
||||
out[2] = m_buffer[m_pos - 3];
|
||||
out[3] = m_buffer[m_pos - 4];
|
||||
return *(uint32*)out;
|
||||
} else {
|
||||
#ifdef G3D_ALLOW_UNALIGNED_WRITES
|
||||
return *(uint32*)(&m_buffer[m_pos - 4]);
|
||||
#else
|
||||
uint8 out[4];
|
||||
out[0] = m_buffer[m_pos - 4];
|
||||
out[1] = m_buffer[m_pos - 3];
|
||||
out[2] = m_buffer[m_pos - 2];
|
||||
out[3] = m_buffer[m_pos - 1];
|
||||
return *(uint32*)out;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline int32 readInt32() {
|
||||
uint32 a = readUInt32();
|
||||
return *(int32*)&a;
|
||||
}
|
||||
|
||||
uint64 readUInt64();
|
||||
|
||||
inline int64 readInt64() {
|
||||
uint64 a = readUInt64();
|
||||
return *(int64*)&a;
|
||||
}
|
||||
|
||||
inline float32 readFloat32() {
|
||||
union {
|
||||
uint32 a;
|
||||
float32 b;
|
||||
};
|
||||
a = readUInt32();
|
||||
return b;
|
||||
}
|
||||
|
||||
inline float64 readFloat64() {
|
||||
union {
|
||||
uint64 a;
|
||||
float64 b;
|
||||
};
|
||||
a = readUInt64();
|
||||
return b;
|
||||
}
|
||||
|
||||
void readBytes(void* bytes, int64 n);
|
||||
|
||||
/**
|
||||
Reads an n character string. The string is not
|
||||
required to end in NULL in the file but will
|
||||
always be a proper std::string when returned.
|
||||
*/
|
||||
std::string readString(int64 n);
|
||||
|
||||
/**
|
||||
Reads until NULL or the end of the file is encountered.
|
||||
*/
|
||||
std::string readString();
|
||||
|
||||
/**
|
||||
Reads until NULL or the end of the file is encountered.
|
||||
If the string has odd length (including NULL), reads
|
||||
another byte.
|
||||
*/
|
||||
std::string readStringEven();
|
||||
|
||||
|
||||
std::string readString32();
|
||||
|
||||
Vector4 readVector4();
|
||||
Vector3 readVector3();
|
||||
Vector2 readVector2();
|
||||
|
||||
Color4 readColor4();
|
||||
Color3 readColor3();
|
||||
|
||||
/**
|
||||
Skips ahead n bytes.
|
||||
*/
|
||||
inline void skip(int64 n) {
|
||||
setPosition(m_pos + m_alreadyRead + n);
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if the position is not at the end of the file
|
||||
*/
|
||||
inline bool hasMore() const {
|
||||
return m_pos + m_alreadyRead < m_length;
|
||||
}
|
||||
|
||||
/** Prepares for bit reading via readBits. Only readBits can be
|
||||
called between beginBits and endBits without corrupting the
|
||||
data stream. */
|
||||
void beginBits();
|
||||
|
||||
/** Can only be called between beginBits and endBits */
|
||||
uint32 readBits(int numBits);
|
||||
|
||||
/** Ends bit-reading. */
|
||||
void endBits();
|
||||
|
||||
# define DECLARE_READER(ucase, lcase)\
|
||||
void read##ucase(lcase* out, int64 n);\
|
||||
void read##ucase(std::vector<lcase>& out, int64 n);\
|
||||
void read##ucase(Array<lcase>& out, int64 n);
|
||||
|
||||
DECLARE_READER(Bool8, bool)
|
||||
DECLARE_READER(UInt8, uint8)
|
||||
DECLARE_READER(Int8, int8)
|
||||
DECLARE_READER(UInt16, uint16)
|
||||
DECLARE_READER(Int16, int16)
|
||||
DECLARE_READER(UInt32, uint32)
|
||||
DECLARE_READER(Int32, int32)
|
||||
DECLARE_READER(UInt64, uint64)
|
||||
DECLARE_READER(Int64, int64)
|
||||
DECLARE_READER(Float32, float32)
|
||||
DECLARE_READER(Float64, float64)
|
||||
# undef DECLARE_READER
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,421 @@
|
||||
/**
|
||||
@file BinaryOutput.h
|
||||
|
||||
@maintainer Morgan McGuire, graphics3d.com
|
||||
|
||||
@created 2001-08-09
|
||||
@edited 2008-01-24
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_BINARYOUTPUT_H
|
||||
#define G3D_BINARYOUTPUT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <assert.h>
|
||||
#include <string>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <stdio.h>
|
||||
#include "G3D/Color4.h"
|
||||
#include "G3D/Color3.h"
|
||||
#include "G3D/Vector4.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector2.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/debug.h"
|
||||
#include "G3D/BinaryInput.h"
|
||||
#include "G3D/System.h"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (push)
|
||||
// Conditional is constant (wrong in inline)
|
||||
# pragma warning (disable : 4127)
|
||||
#endif
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Sequential or random access byte-order independent binary file access.
|
||||
|
||||
The compress() call can be used to compress with zlib.
|
||||
|
||||
Any method call can trigger an out of memory error (thrown as char*)
|
||||
when writing to "<memory>" instead of a file.
|
||||
|
||||
Compressed writing and seeking backwards is not supported for huge files
|
||||
(i.e., BinaryOutput may have to dump the contents to disk if they
|
||||
exceed available RAM).
|
||||
*/
|
||||
class BinaryOutput {
|
||||
private:
|
||||
std::string m_filename;
|
||||
|
||||
bool m_committed;
|
||||
|
||||
/** 0 outside of beginBits...endBits, 1 inside */
|
||||
int m_beginEndBits;
|
||||
|
||||
/** The current string of bits being built up by beginBits...endBits.
|
||||
This string is treated semantically, as if the lowest bit was
|
||||
on the left and the highest was on the right.*/
|
||||
int8 m_bitString;
|
||||
|
||||
/** Position (from the lowest bit) currently used in bitString.*/
|
||||
int m_bitPos;
|
||||
|
||||
// True if the file endianess does not match the machine endian
|
||||
bool m_swapBytes;
|
||||
|
||||
G3DEndian m_fileEndian;
|
||||
|
||||
uint8* m_buffer;
|
||||
|
||||
/** Size of the elements used */
|
||||
int m_bufferLen;
|
||||
|
||||
/** Underlying size of memory allocaded */
|
||||
int m_maxBufferLen;
|
||||
|
||||
/** Next byte in file */
|
||||
int m_pos;
|
||||
|
||||
/** is this initialized? */
|
||||
bool m_init;
|
||||
|
||||
/** Number of bytes already written to the file.*/
|
||||
size_t m_alreadyWritten;
|
||||
|
||||
bool m_ok;
|
||||
|
||||
void reserveBytesWhenOutOfMemory(size_t bytes);
|
||||
|
||||
void reallocBuffer(size_t bytes, size_t oldBufferLen);
|
||||
|
||||
/**
|
||||
Make sure at least bytes can be written, resizing if
|
||||
necessary.
|
||||
*/
|
||||
inline void reserveBytes(int bytes) {
|
||||
debugAssert(bytes > 0);
|
||||
size_t oldBufferLen = (size_t)m_bufferLen;
|
||||
|
||||
m_bufferLen = iMax(m_bufferLen, (m_pos + bytes));
|
||||
if (m_bufferLen > m_maxBufferLen) {
|
||||
reallocBuffer(bytes, oldBufferLen);
|
||||
}
|
||||
}
|
||||
|
||||
// Not implemented on purpose, don't use
|
||||
BinaryOutput(const BinaryOutput&);
|
||||
BinaryOutput& operator=(const BinaryOutput&);
|
||||
bool operator==(const BinaryOutput&);
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
You must call setEndian() if you use this (memory) constructor.
|
||||
*/
|
||||
BinaryOutput();
|
||||
|
||||
/**
|
||||
Doesn't actually open the file; commit() does that.
|
||||
Use "<memory>" as the filename if you're going to commit
|
||||
to memory.
|
||||
*/
|
||||
BinaryOutput(
|
||||
const std::string& filename,
|
||||
G3DEndian fileEndian);
|
||||
|
||||
~BinaryOutput();
|
||||
|
||||
/** Compresses the data in the buffer in place,
|
||||
preceeding it with a little-endian uint32 indicating
|
||||
the uncompressed size.
|
||||
|
||||
Call immediately before commit().
|
||||
|
||||
Cannot be used for huge files (ones where the data
|
||||
was already written to disk)-- will throw char*.
|
||||
*/
|
||||
void compress();
|
||||
|
||||
/** True if no errors have been encountered.*/
|
||||
bool ok() const;
|
||||
|
||||
/**
|
||||
Returns a pointer to the internal memory buffer.
|
||||
*/
|
||||
inline const uint8* getCArray() const {
|
||||
return m_buffer;
|
||||
}
|
||||
|
||||
void setEndian(G3DEndian fileEndian);
|
||||
|
||||
G3DEndian endian() const {
|
||||
return m_fileEndian;
|
||||
}
|
||||
|
||||
std::string getFilename() const {
|
||||
return m_filename;
|
||||
}
|
||||
|
||||
/**
|
||||
Write the bytes to disk. It is ok to call this
|
||||
multiple times; it will just overwrite the previous file.
|
||||
|
||||
Parent directories are created as needed if they do
|
||||
not exist.
|
||||
|
||||
<B>Not</B> called from the destructor; you must call
|
||||
it yourself.
|
||||
|
||||
@param flush If true (default) the file is ready for reading when the method returns, otherwise
|
||||
the method returns immediately and writes the file in the background.
|
||||
*/
|
||||
void commit(bool flush = true);
|
||||
|
||||
/**
|
||||
Write the bytes to memory (which must be of
|
||||
at least size() bytes).
|
||||
*/
|
||||
void commit(uint8*);
|
||||
|
||||
/**
|
||||
A memory BinaryOutput may be reset so that it can be written to again
|
||||
without allocating new memory. The underlying array will not be deallocated,
|
||||
but the reset structure will act like a newly intialized one.
|
||||
*/
|
||||
void reset();
|
||||
|
||||
|
||||
inline int length() const {
|
||||
return (int)m_bufferLen + (int)m_alreadyWritten;
|
||||
}
|
||||
|
||||
inline int size() const {
|
||||
return length();
|
||||
}
|
||||
|
||||
/**
|
||||
Sets the length of the file to n, padding
|
||||
with 0's past the current end. Does not
|
||||
change the position of the next byte to be
|
||||
written unless n < size().
|
||||
|
||||
Throws char* when resetting a huge file to be shorter
|
||||
than its current length.
|
||||
*/
|
||||
inline void setLength(int n) {
|
||||
n = n - (int)m_alreadyWritten;
|
||||
|
||||
if (n < 0) {
|
||||
throw "Cannot resize huge files to be shorter.";
|
||||
}
|
||||
|
||||
if (n < m_bufferLen) {
|
||||
m_pos = n;
|
||||
}
|
||||
if (n > m_bufferLen) {
|
||||
reserveBytes(n - m_bufferLen);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the current byte position in the file,
|
||||
where 0 is the beginning and getLength() - 1 is the end.
|
||||
*/
|
||||
inline int64 position() const {
|
||||
return (int64)m_pos + (int64)m_alreadyWritten;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Sets the position. Can set past length, in which case
|
||||
the file is padded with zeros up to one byte before the
|
||||
next to be written.
|
||||
|
||||
May throw a char* exception when seeking backwards on a huge file.
|
||||
*/
|
||||
inline void setPosition(int64 p) {
|
||||
p = p - (int64)m_alreadyWritten;
|
||||
|
||||
if (p > m_bufferLen) {
|
||||
setLength((int)(p + (int64)m_alreadyWritten));
|
||||
}
|
||||
|
||||
if (p < 0) {
|
||||
throw "Cannot seek more than 10 MB backwards on huge files.";
|
||||
}
|
||||
|
||||
m_pos = (int)p;
|
||||
}
|
||||
|
||||
|
||||
void writeBytes(
|
||||
const void* b,
|
||||
int count) {
|
||||
|
||||
reserveBytes(count);
|
||||
debugAssert(m_pos >= 0);
|
||||
debugAssert(m_bufferLen >= count);
|
||||
System::memcpy(m_buffer + m_pos, b, count);
|
||||
m_pos += count;
|
||||
}
|
||||
|
||||
/**
|
||||
Writes a signed 8-bit integer to the current position.
|
||||
*/
|
||||
inline void writeInt8(int8 i) {
|
||||
reserveBytes(1);
|
||||
m_buffer[m_pos] = *(uint8*)&i;
|
||||
m_pos++;
|
||||
}
|
||||
|
||||
inline void writeBool8(bool b) {
|
||||
writeInt8(b ? 1 : 0);
|
||||
}
|
||||
|
||||
inline void writeUInt8(uint8 i) {
|
||||
reserveBytes(1);
|
||||
m_buffer[m_pos] = i;
|
||||
m_pos++;
|
||||
}
|
||||
|
||||
void writeUInt16(uint16 u);
|
||||
|
||||
inline void writeInt16(int16 i) {
|
||||
writeUInt16(*(uint16*)&i);
|
||||
}
|
||||
|
||||
void writeUInt32(uint32 u);
|
||||
|
||||
inline void writeInt32(int32 i) {
|
||||
debugAssert(m_beginEndBits == 0);
|
||||
writeUInt32(*(uint32*)&i);
|
||||
}
|
||||
|
||||
void writeUInt64(uint64 u);
|
||||
|
||||
inline void writeInt64(int64 i) {
|
||||
writeUInt64(*(uint64*)&i);
|
||||
}
|
||||
|
||||
inline void writeFloat32(float32 f) {
|
||||
debugAssert(m_beginEndBits == 0);
|
||||
union {
|
||||
float32 a;
|
||||
uint32 b;
|
||||
};
|
||||
a = f;
|
||||
writeUInt32(b);
|
||||
}
|
||||
|
||||
inline void writeFloat64(float64 f) {
|
||||
union {
|
||||
float64 a;
|
||||
uint64 b;
|
||||
};
|
||||
a = f;
|
||||
writeUInt64(b);
|
||||
}
|
||||
|
||||
/**
|
||||
Write a string with NULL termination.
|
||||
*/
|
||||
inline void writeString(const std::string& s) {
|
||||
writeString(s.c_str());
|
||||
}
|
||||
|
||||
void writeString(const char* s);
|
||||
|
||||
/**
|
||||
Write a string, ensuring that the total length
|
||||
including NULL is even.
|
||||
*/
|
||||
void writeStringEven(const std::string& s) {
|
||||
writeStringEven(s.c_str());
|
||||
}
|
||||
|
||||
void writeStringEven(const char* s);
|
||||
|
||||
|
||||
void writeString32(const char* s);
|
||||
|
||||
/**
|
||||
Write a string with a 32-bit length field in front
|
||||
of it.
|
||||
*/
|
||||
void writeString32(const std::string& s) {
|
||||
writeString32(s.c_str());
|
||||
}
|
||||
|
||||
void writeVector4(const Vector4& v);
|
||||
|
||||
void writeVector3(const Vector3& v);
|
||||
|
||||
void writeVector2(const Vector2& v);
|
||||
|
||||
void writeColor4(const Color4& v);
|
||||
|
||||
void writeColor3(const Color3& v);
|
||||
|
||||
/**
|
||||
Skips ahead n bytes.
|
||||
*/
|
||||
inline void skip(int n) {
|
||||
if (m_pos + n > m_bufferLen) {
|
||||
setLength((int)m_pos + (int)m_alreadyWritten + n);
|
||||
}
|
||||
m_pos += n;
|
||||
}
|
||||
|
||||
/** Call before a series of BinaryOutput::writeBits calls. Only writeBits
|
||||
can be called between beginBits and endBits without corrupting the stream.*/
|
||||
void beginBits();
|
||||
|
||||
/** Write numBits from bitString to the output stream. Bits are numbered from
|
||||
low to high.
|
||||
|
||||
Can only be
|
||||
called between beginBits and endBits. Bits written are semantically
|
||||
little-endian, regardless of the actual endian-ness of the system. That is,
|
||||
<CODE>writeBits(0xABCD, 16)</CODE> writes 0xCD to the first byte and
|
||||
0xAB to the second byte. However, if used with BinaryInput::readBits, the ordering
|
||||
is transparent to the caller.
|
||||
*/
|
||||
void writeBits(uint32 bitString, int numBits);
|
||||
|
||||
/** Call after a series of BinaryOutput::writeBits calls. This will
|
||||
finish out with zeros the last byte into which bits were written.*/
|
||||
void endBits();
|
||||
|
||||
|
||||
# define DECLARE_WRITER(ucase, lcase)\
|
||||
void write##ucase(const lcase* out, int n);\
|
||||
void write##ucase(const std::vector<lcase>& out, int n);\
|
||||
void write##ucase(const Array<lcase>& out, int n);
|
||||
|
||||
DECLARE_WRITER(Bool8, bool)
|
||||
DECLARE_WRITER(UInt8, uint8)
|
||||
DECLARE_WRITER(Int8, int8)
|
||||
DECLARE_WRITER(UInt16, uint16)
|
||||
DECLARE_WRITER(Int16, int16)
|
||||
DECLARE_WRITER(UInt32, uint32)
|
||||
DECLARE_WRITER(Int32, int32)
|
||||
DECLARE_WRITER(UInt64, uint64)
|
||||
DECLARE_WRITER(Int64, int64)
|
||||
DECLARE_WRITER(Float32, float32)
|
||||
DECLARE_WRITER(Float64, float64)
|
||||
# undef DECLARE_WRITER
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,20 @@
|
||||
/**
|
||||
@file BoundsTrait.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2008-10-01
|
||||
@edited 2008-10-01
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_BOUNDSTRAIT_H
|
||||
#define G3D_BOUNDSTRAIT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
|
||||
template<typename Value>
|
||||
struct BoundsTrait{};
|
||||
|
||||
#endif
|
||||
|
||||
+193
@@ -0,0 +1,193 @@
|
||||
/**
|
||||
@file Box.h
|
||||
|
||||
Box class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@cite Portions based on Dave Eberly's Magic Software Library at <A HREF="http://www.magic-software.com">http://www.magic-software.com</A>
|
||||
@created 2001-06-02
|
||||
@edited 2007-06-05
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_BOX_H
|
||||
#define G3D_BOX_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Plane.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class CoordinateFrame;
|
||||
|
||||
/**
|
||||
An arbitrary 3D box, useful as a bounding box.
|
||||
|
||||
|
||||
To construct a box from a coordinate frame, center and extent, use the idiom:
|
||||
|
||||
<CODE>Box box = cframe.toObjectSpace(Box(center - extent/2, center + extent/2));</CODE>
|
||||
*/
|
||||
class Box {
|
||||
private:
|
||||
|
||||
static int32 dummy;
|
||||
|
||||
friend class CoordinateFrame;
|
||||
|
||||
/**
|
||||
<PRE>
|
||||
3 2 7 6
|
||||
|
||||
0 1 4 5
|
||||
|
||||
front back (seen through front)
|
||||
</PRE>
|
||||
*/
|
||||
Vector3 _corner[8];
|
||||
|
||||
/**
|
||||
Unit axes.
|
||||
*/
|
||||
Vector3 _axis[3];
|
||||
|
||||
Vector3 _center;
|
||||
|
||||
/**
|
||||
Extent along each axis.
|
||||
*/
|
||||
Vector3 _extent;
|
||||
|
||||
float _area;
|
||||
float _volume;
|
||||
|
||||
void init(
|
||||
const Vector3& min,
|
||||
const Vector3& max);
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
Does not initialize the fields.
|
||||
*/
|
||||
Box();
|
||||
|
||||
/**
|
||||
Constructs a box from two opposite corners.
|
||||
*/
|
||||
Box(
|
||||
const Vector3& min,
|
||||
const Vector3& max);
|
||||
|
||||
static Box inf();
|
||||
|
||||
Box(class BinaryInput& b);
|
||||
|
||||
Box(const class AABox& b);
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
/**
|
||||
Returns the object to world transformation for
|
||||
this box. localFrame().worldToObject(...) takes
|
||||
objects into the space where the box axes are
|
||||
(1,0,0), (0,1,0), (0,0,1). Note that there
|
||||
is no scaling in this transformation.
|
||||
*/
|
||||
CoordinateFrame localFrame() const;
|
||||
|
||||
void getLocalFrame(CoordinateFrame& frame) const;
|
||||
|
||||
/**
|
||||
Returns the centroid of the box.
|
||||
*/
|
||||
inline Vector3 center() const {
|
||||
return _center;
|
||||
}
|
||||
|
||||
|
||||
inline Vector3 corner(int i) const {
|
||||
debugAssert(i < 8);
|
||||
return _corner[i];
|
||||
}
|
||||
|
||||
/**
|
||||
Unit length.
|
||||
*/
|
||||
inline Vector3 axis(int a) const {
|
||||
debugAssert(a < 3);
|
||||
return _axis[a];
|
||||
}
|
||||
|
||||
/**
|
||||
Distance from corner(0) to the next corner
|
||||
along the box's local axis a.
|
||||
*/
|
||||
inline float extent(int a) const {
|
||||
debugAssert(a < 3);
|
||||
return (float)_extent[a];
|
||||
}
|
||||
|
||||
inline Vector3 extent() const {
|
||||
return _extent;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the four corners of a face (0 <= f < 6).
|
||||
The corners are returned to form a counter clockwise quad facing outwards.
|
||||
*/
|
||||
void getFaceCorners(
|
||||
int f,
|
||||
Vector3& v0,
|
||||
Vector3& v1,
|
||||
Vector3& v2,
|
||||
Vector3& v3) const;
|
||||
|
||||
|
||||
/**
|
||||
See AABox::culledBy
|
||||
*/
|
||||
bool culledBy(
|
||||
const Array<Plane>& plane,
|
||||
int32& cullingPlaneIndex,
|
||||
const uint32 testMask,
|
||||
uint32& childMask) const;
|
||||
|
||||
/**
|
||||
Conservative culling test that does not produce a mask for children.
|
||||
*/
|
||||
bool culledBy(
|
||||
const Array<Plane>& plane,
|
||||
int32& cullingPlaneIndex = dummy,
|
||||
const uint32 testMask = -1) const;
|
||||
|
||||
bool contains(
|
||||
const Vector3& point) const;
|
||||
|
||||
float area() const;
|
||||
|
||||
float volume() const;
|
||||
|
||||
void getRandomSurfacePoint(Vector3& P, Vector3& N = Vector3::dummy) const;
|
||||
|
||||
/**
|
||||
Uniformly distributed on the interior (includes surface)
|
||||
*/
|
||||
Vector3 randomInteriorPoint() const;
|
||||
|
||||
void getBounds(class AABox&) const;
|
||||
|
||||
bool isFinite() const {
|
||||
return G3D::isFinite(_volume);
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+90
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
@file Capsule.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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
|
||||
File diff suppressed because it is too large
Load Diff
+129
@@ -0,0 +1,129 @@
|
||||
/**
|
||||
@file Color1.h
|
||||
|
||||
Monochrome Color class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2007-01-31
|
||||
@edited 2008-10-02
|
||||
|
||||
Copyright 2000-2008, 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 <string>
|
||||
|
||||
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) {
|
||||
}
|
||||
|
||||
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<G3D::Color1> {
|
||||
static size_t hashCode(const G3D::Color1& key) {
|
||||
return key.hashCode();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
/**
|
||||
@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 {
|
||||
|
||||
#if defined(G3D_WIN32)
|
||||
// Switch to tight alignment
|
||||
#pragma pack(push, 1)
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
Represents a Color1 as a packed integer. Convenient
|
||||
for creating unsigned int vertex arrays.
|
||||
|
||||
<B>WARNING</B>: 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).
|
||||
|
||||
<B>Note</B>:
|
||||
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:
|
||||
|
||||
<pre>
|
||||
let s = 0.5/255
|
||||
float int size
|
||||
[0, s) -> 0 s
|
||||
[s, s * 3) -> 1 2*s
|
||||
(1 - s, 1] -> 255 s
|
||||
</pre>
|
||||
|
||||
If we use max(floor(x * 256), 255), then we get:
|
||||
|
||||
<pre>
|
||||
let s = 1/256
|
||||
float int size
|
||||
[0, s) -> 0 s
|
||||
[s, 2 * s) -> 1 s
|
||||
(1 - s, 1] -> 255 s
|
||||
</PRE>
|
||||
and the intervals are all the same size, thus giving equal precision to all values.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#if defined(G3D_LINUX) || defined(G3D_OSX)
|
||||
__attribute((aligned(1)))
|
||||
#endif
|
||||
|
||||
;
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+390
@@ -0,0 +1,390 @@
|
||||
/**
|
||||
@file Color3.h
|
||||
|
||||
Color class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@cite Portions based on Dave Eberly's Magic Software Library
|
||||
at <A HREF="http://www.magic-software.com">http://www.magic-software.com</A>
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2008-07-17
|
||||
|
||||
Copyright 2000-2008, 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 <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
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();
|
||||
|
||||
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]);
|
||||
|
||||
/**
|
||||
Initialize from another color.
|
||||
*/
|
||||
Color3 (const Color3& other);
|
||||
|
||||
Color3 (const class Color3uint8& other);
|
||||
|
||||
/**
|
||||
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();
|
||||
|
||||
/**
|
||||
* 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;
|
||||
Color3 operator* (float fScalar) const;
|
||||
Color3 operator* (const Color3& rkVector) const;
|
||||
Color3 operator/ (float fScalar) const;
|
||||
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;
|
||||
|
||||
inline operator float* () {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
operator const float* () const {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
// 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));
|
||||
}
|
||||
|
||||
/**@return the largest component */
|
||||
inline float max() const {
|
||||
return G3D::max(G3D::max(r, g), b);
|
||||
}
|
||||
|
||||
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));
|
||||
}
|
||||
|
||||
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* (float fScalar) const {
|
||||
return Color3(fScalar*r, fScalar*g, fScalar*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<G3D::Color3> {
|
||||
static size_t hashCode(const G3D::Color3& key) {
|
||||
return key.hashCode();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
/**
|
||||
@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.
|
||||
|
||||
<B>WARNING</B>: 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).
|
||||
*/
|
||||
|
||||
#if defined(G3D_WIN32)
|
||||
// Switch to tight alignment
|
||||
#pragma pack(push, 1)
|
||||
#endif
|
||||
|
||||
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
|
||||
G3D::uint8& operator[] (int i) const;
|
||||
operator G3D::uint8* ();
|
||||
operator const G3D::uint8* () const;
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(G3D_LINUX) || defined(G3D_OSX)
|
||||
__attribute((aligned(1)))
|
||||
#endif
|
||||
|
||||
;
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
|
||||
inline G3D::uint8& Color3uint8::operator[] (int i) const {
|
||||
debugAssert((unsigned int)i < 3);
|
||||
return ((G3D::uint8*)this)[i];
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Color3uint8::operator G3D::uint8* () {
|
||||
return (G3D::uint8*)this;
|
||||
}
|
||||
|
||||
inline Color3uint8::operator const G3D::uint8* () const {
|
||||
return (G3D::uint8*)this;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
+324
@@ -0,0 +1,324 @@
|
||||
/**
|
||||
@file Color4.h
|
||||
|
||||
Color class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@cite Portions based on Dave Eberly's Magic Software Library
|
||||
at <A HREF="http://www.magic-software.com">http://www.magic-software.com</A>
|
||||
|
||||
@created 2002-06-25
|
||||
@edited 2008-07-16
|
||||
|
||||
Copyright 2000-2008, 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 <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
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:
|
||||
|
||||
/**
|
||||
* 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);
|
||||
|
||||
/**
|
||||
* Initialize from G3D::Reals.
|
||||
*/
|
||||
Color4(float r, float g, float b, float a = 1.0);
|
||||
|
||||
/**
|
||||
* Initialize from array of G3D::Reals.
|
||||
*/
|
||||
Color4(float value[4]);
|
||||
|
||||
/**
|
||||
* Initialize from another color.
|
||||
*/
|
||||
Color4(const Color4& other);
|
||||
|
||||
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;
|
||||
operator float* ();
|
||||
operator const float* () 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;
|
||||
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();
|
||||
|
||||
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 Color4::operator float* () {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
inline Color4::operator const float* () const {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
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<G3D::Color4> {
|
||||
static size_t hashCode(const G3D::Color4& key) {
|
||||
return key.hashCode();
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
+133
@@ -0,0 +1,133 @@
|
||||
/**
|
||||
@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.
|
||||
|
||||
<B>WARNING</B>: 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).
|
||||
|
||||
*/
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
// Switch to tight alignment
|
||||
#pragma pack(push, 1)
|
||||
#endif
|
||||
|
||||
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
|
||||
G3D::uint8& operator[] (int i) const;
|
||||
operator G3D::uint8* ();
|
||||
operator const G3D::uint8* () const;
|
||||
|
||||
|
||||
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<const uint32*>(this) == *reinterpret_cast<const uint32*>(&other);
|
||||
}
|
||||
|
||||
bool operator!=(const Color4uint8& other) const {
|
||||
return *reinterpret_cast<const uint32*>(this) != *reinterpret_cast<const uint32*>(&other);
|
||||
}
|
||||
|
||||
}
|
||||
#if defined(G3D_LINUX) || defined(G3D_OSX)
|
||||
__attribute((aligned(1)))
|
||||
#endif
|
||||
;
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
|
||||
inline G3D::uint8& Color4uint8::operator[] (int i) const {
|
||||
return ((G3D::uint8*)this)[i];
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Color4uint8::operator G3D::uint8* () {
|
||||
return (G3D::uint8*)this;
|
||||
}
|
||||
|
||||
inline Color4uint8::operator const G3D::uint8* () const {
|
||||
return (G3D::uint8*)this;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+68
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
@file Cone.h
|
||||
|
||||
Cone class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@cite Portions based on Dave Eberly's Magic Software Library at <A HREF="http://www.magic-software.com">http://www.magic-software.com</A>
|
||||
|
||||
@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
|
||||
@@ -0,0 +1,179 @@
|
||||
/**
|
||||
@file ConvexPolyhedron.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<Vector3> _vertex;
|
||||
|
||||
public:
|
||||
|
||||
ConvexPolygon() {}
|
||||
ConvexPolygon(const Array<Vector3>& __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<ConvexPolygon> face;
|
||||
|
||||
ConvexPolyhedron() {}
|
||||
ConvexPolyhedron(const Array<ConvexPolygon>& _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<Vector2> 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<Vector2>& 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
|
||||
@@ -0,0 +1,315 @@
|
||||
/**
|
||||
@file CoordinateFrame.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-03-04
|
||||
@edited 2008-07-14
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_COORDINATEFRAME_H
|
||||
#define G3D_COORDINATEFRAME_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector4.h"
|
||||
#include "G3D/Matrix3.h"
|
||||
#include "G3D/Array.h"
|
||||
#include <math.h>
|
||||
#include <string>
|
||||
#include <stdio.h>
|
||||
#include <cstdarg>
|
||||
#include <assert.h>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A rigid body RT (rotation-translation) transformation.
|
||||
|
||||
CoordinateFrame abstracts a 4x4 matrix that maps object space to world space:
|
||||
|
||||
v_world = C * v_object
|
||||
|
||||
CoordinateFrame::rotation is the upper 3x3 submatrix, CoordinateFrame::translation
|
||||
is the right 3x1 column. The 4th row is always [0 0 0 1], so it isn't stored.
|
||||
So you don't have to remember which way the multiplication and transformation work,
|
||||
it provides explicit toWorldSpace and toObjectSpace methods. Also, points, vectors
|
||||
(directions), and surface normals transform differently, so they have separate methods.
|
||||
|
||||
Some helper functions transform whole primitives like boxes in and out of object space.
|
||||
|
||||
Convert to Matrix4 using CoordinateFrame::toMatrix4. You <I>can</I> construct a CoordinateFrame
|
||||
from a Matrix4 using Matrix4::approxCoordinateFrame, however, because a Matrix4 is more
|
||||
general than a CoordinateFrame, some information may be lost.
|
||||
|
||||
@sa G3D::UprightFrame, G3D::PhysicsFrame, G3D::Matrix4, G3D::Quat
|
||||
*/
|
||||
class CoordinateFrame {
|
||||
public:
|
||||
|
||||
/** Takes object space points to world space. */
|
||||
Matrix3 rotation;
|
||||
|
||||
/** Takes object space points to world space. */
|
||||
Vector3 translation;
|
||||
|
||||
inline bool operator==(const CoordinateFrame& other) const {
|
||||
return (translation == other.translation) && (rotation == other.rotation);
|
||||
}
|
||||
|
||||
inline bool operator!=(const CoordinateFrame& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
bool fuzzyEq(const CoordinateFrame& other) const;
|
||||
|
||||
bool fuzzyIsIdentity() const;
|
||||
|
||||
bool isIdentity() const;
|
||||
|
||||
/**
|
||||
Initializes to the identity coordinate frame.
|
||||
*/
|
||||
inline CoordinateFrame() :
|
||||
rotation(Matrix3::identity()), translation(Vector3::zero()) {
|
||||
}
|
||||
|
||||
CoordinateFrame(const Vector3& _translation) :
|
||||
rotation(Matrix3::identity()), translation(_translation) {
|
||||
}
|
||||
|
||||
CoordinateFrame(const Matrix3 &rotation, const Vector3 &translation) :
|
||||
rotation(rotation), translation(translation) {
|
||||
}
|
||||
|
||||
CoordinateFrame(const Matrix3 &rotation) :
|
||||
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) {}
|
||||
|
||||
/**
|
||||
Computes the inverse of this coordinate frame.
|
||||
*/
|
||||
inline CoordinateFrame inverse() const {
|
||||
CoordinateFrame out;
|
||||
out.rotation = rotation.transpose();
|
||||
out.translation = -out.rotation * translation;
|
||||
return out;
|
||||
}
|
||||
|
||||
inline ~CoordinateFrame() {}
|
||||
|
||||
/** 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;
|
||||
|
||||
/**
|
||||
Returns the heading of the lookVector as an angle in radians relative to
|
||||
the world -z axis. That is, a counter-clockwise heading where north (-z)
|
||||
is 0 and west (-x) is PI/2.
|
||||
|
||||
Note that the heading ignores the Y axis, so an inverted
|
||||
object has an inverted heading.
|
||||
*/
|
||||
inline float getHeading() const {
|
||||
Vector3 look = rotation.getColumn(2);
|
||||
float angle = -(float) atan2(-look.x, look.z);
|
||||
return angle;
|
||||
}
|
||||
|
||||
/**
|
||||
Takes the coordinate frame into object space.
|
||||
this->inverse() * c
|
||||
*/
|
||||
inline CoordinateFrame toObjectSpace(const CoordinateFrame& c) const {
|
||||
return this->inverse() * c;
|
||||
}
|
||||
|
||||
inline Vector4 toObjectSpace(const Vector4& v) const {
|
||||
return this->inverse().toWorldSpace(v);
|
||||
}
|
||||
|
||||
inline Vector4 toWorldSpace(const Vector4& v) const {
|
||||
return Vector4(rotation * Vector3(v.x, v.y, v.z) + translation * v.w, v.w);
|
||||
}
|
||||
|
||||
/**
|
||||
Transforms the point into world space.
|
||||
*/
|
||||
inline Vector3 pointToWorldSpace(const Vector3& v) const {
|
||||
return Vector3(
|
||||
rotation[0][0] * v[0] + rotation[0][1] * v[1] + rotation[0][2] * v[2] + translation[0],
|
||||
rotation[1][0] * v[0] + rotation[1][1] * v[1] + rotation[1][2] * v[2] + translation[1],
|
||||
rotation[2][0] * v[0] + rotation[2][1] * v[1] + rotation[2][2] * v[2] + translation[2]);
|
||||
}
|
||||
|
||||
/**
|
||||
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];
|
||||
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]);
|
||||
}
|
||||
|
||||
/**
|
||||
Transforms the vector into world space (no translation).
|
||||
*/
|
||||
inline Vector3 vectorToWorldSpace(const Vector3& v) const {
|
||||
return rotation * v;
|
||||
}
|
||||
|
||||
inline Vector3 normalToWorldSpace(const Vector3& v) const {
|
||||
return rotation * v;
|
||||
}
|
||||
|
||||
class Ray toObjectSpace(const Ray& r) const;
|
||||
|
||||
Ray toWorldSpace(const Ray& r) const;
|
||||
|
||||
/**
|
||||
Transforms the vector into object space (no translation).
|
||||
*/
|
||||
inline Vector3 vectorToObjectSpace(const Vector3 &v) const {
|
||||
// Multiply on the left (same as rotation.transpose() * v)
|
||||
return v * rotation;
|
||||
}
|
||||
|
||||
inline Vector3 normalToObjectSpace(const Vector3 &v) const {
|
||||
// Multiply on the left (same as rotation.transpose() * v)
|
||||
return v * rotation;
|
||||
}
|
||||
|
||||
void pointToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;
|
||||
|
||||
void normalToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;
|
||||
|
||||
void vectorToWorldSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;
|
||||
|
||||
void pointToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;
|
||||
|
||||
void normalToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;
|
||||
|
||||
void vectorToObjectSpace(const Array<Vector3>& v, Array<Vector3>& vout) const;
|
||||
|
||||
class Box toWorldSpace(const class AABox& b) const;
|
||||
|
||||
class Box toWorldSpace(const class Box& b) const;
|
||||
|
||||
class Cylinder toWorldSpace(const class Cylinder& b) const;
|
||||
|
||||
class Capsule toWorldSpace(const class Capsule& b) const;
|
||||
|
||||
class Plane toWorldSpace(const class Plane& p) const;
|
||||
|
||||
class Sphere toWorldSpace(const class Sphere& b) const;
|
||||
|
||||
class Triangle toWorldSpace(const class Triangle& t) const;
|
||||
|
||||
class Box toObjectSpace(const AABox& b) const;
|
||||
|
||||
class Box toObjectSpace(const Box& b) const;
|
||||
|
||||
class Plane toObjectSpace(const Plane& p) const;
|
||||
|
||||
class Sphere toObjectSpace(const Sphere& b) const;
|
||||
|
||||
Triangle toObjectSpace(const Triangle& t) const;
|
||||
|
||||
/** Compose: create the transformation that is <I>other</I> followed by <I>this</I>.*/
|
||||
CoordinateFrame operator*(const CoordinateFrame &other) const {
|
||||
return CoordinateFrame(rotation * other.rotation,
|
||||
pointToWorldSpace(other.translation));
|
||||
}
|
||||
|
||||
CoordinateFrame operator+(const Vector3& v) const {
|
||||
return CoordinateFrame(rotation, translation + v);
|
||||
}
|
||||
|
||||
CoordinateFrame operator-(const Vector3& v) const {
|
||||
return CoordinateFrame(rotation, translation - v);
|
||||
}
|
||||
|
||||
void lookAt(const Vector3& target);
|
||||
|
||||
void lookAt(
|
||||
const Vector3& target,
|
||||
Vector3 up);
|
||||
|
||||
/** The direction this camera is looking (its negative z axis)*/
|
||||
inline Vector3 lookVector() const {
|
||||
return -rotation.getColumn(2);
|
||||
}
|
||||
|
||||
/** Returns the ray starting at the camera origin travelling in direction CoordinateFrame::lookVector. */
|
||||
class Ray lookRay() const;
|
||||
|
||||
/** Up direction for this camera (its y axis). */
|
||||
inline Vector3 upVector() const {
|
||||
return rotation.getColumn(1);
|
||||
}
|
||||
|
||||
inline Vector3 rightVector() const {
|
||||
return rotation.getColumn(0);
|
||||
}
|
||||
|
||||
/**
|
||||
If a viewer looks along the look vector, this is the viewer's "left".
|
||||
Useful for strafing motions and building alternative coordinate frames.
|
||||
*/
|
||||
inline Vector3 leftVector() const {
|
||||
return -rotation.getColumn(0);
|
||||
}
|
||||
|
||||
/**
|
||||
Linearly interpolates between two coordinate frames, using
|
||||
Quat::slerp for the rotations.
|
||||
*/
|
||||
CoordinateFrame lerp(
|
||||
const CoordinateFrame& other,
|
||||
float alpha) const;
|
||||
|
||||
};
|
||||
|
||||
typedef CoordinateFrame CFrame;
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
+96
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
@file Crypto.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
|
||||
@created 2006-03-29
|
||||
@edited 2006-04-06
|
||||
*/
|
||||
|
||||
#ifndef G3D_CRYPTO_H
|
||||
#define G3D_CRYPTO_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include <string>
|
||||
|
||||
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:
|
||||
|
||||
/**
|
||||
Computes the CRC32 value of a byte array. CRC32 is designed to be a hash
|
||||
function that produces different values for similar strings.
|
||||
|
||||
This implementation is compatible with PKZIP and GZIP.
|
||||
|
||||
Based on http://www.gamedev.net/reference/programming/features/crc32/
|
||||
*/
|
||||
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, [email protected]
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
static int smallPrime(int n);
|
||||
|
||||
/** Returns 1 + the largest value that can be passed to smallPrime. */
|
||||
static int numSmallPrimes();
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,92 @@
|
||||
/**
|
||||
@file Cylinder.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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
|
||||
+589
@@ -0,0 +1,589 @@
|
||||
/**
|
||||
@file Discovery.h
|
||||
|
||||
<H2>Discovery</H2>
|
||||
Discovery is the process by which computers on a Local Area Network (LAN) find
|
||||
one another. The Discovery API allows clients to make a list of servers running
|
||||
the same application. The application typically presents this list to the user
|
||||
so he can choose which server to connect to.
|
||||
<P>
|
||||
Features of the Discovery API:
|
||||
<P>
|
||||
Low network traffic
|
||||
<BR> - Broadcasts mainly occur only when a new machine enters/leaves the network
|
||||
<BR>Responsive
|
||||
<BR> - Servers appear immediately after launching
|
||||
<BR> - Servers disappear immedatiately after they shut down
|
||||
<BR>Extensible
|
||||
<BR> - Add your own game information (e.g. score, num players, map name)
|
||||
<BR>Versioned
|
||||
<BR> - Tracks incompatible servers so end-users know to upgrade their client/server
|
||||
|
||||
<H2>Using the Discovery API</H2>
|
||||
|
||||
Subclass DiscoveryAdvertisement to add fields describing a server running your
|
||||
application. For a game, these might be the current map name and the number
|
||||
of players.
|
||||
<P>
|
||||
On the client, create an instance of DiscoveryClient<your advertisement subclass>.
|
||||
On the server, create an instance of DiscoveryServer and initialize it with an
|
||||
instance of your advertisement subclass. From your main loop, call doNetwork()
|
||||
on the client and server instances. When your server shuts down, invoke cleanup()
|
||||
on it.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-06-26
|
||||
@edited 2008-11-24
|
||||
*/
|
||||
|
||||
#ifndef G3D_DISCOVERY_H
|
||||
#define G3D_DISCOVERY_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/G3DGameUnits.h"
|
||||
#include "G3D/NetworkDevice.h"
|
||||
#include "G3D/Log.h"
|
||||
#include <time.h>
|
||||
|
||||
/**
|
||||
Different versions of G3D discovery protocols can't communicate with each other.
|
||||
*/
|
||||
#define G3D_DISCOVERY_PROTOCOL_NAME "G3D DISC"
|
||||
#define G3D_DISCOVERY_PROTOCOL_VERSION 1
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
If a machine is running two different programs using discovery they
|
||||
must have different ports. However different programs can share the
|
||||
same ports if they run on the same LAN with different servers.
|
||||
|
||||
@deprecated See Discovery2::Settings
|
||||
*/
|
||||
class DiscoverySettings {
|
||||
public:
|
||||
|
||||
/**
|
||||
Name of the program using discovery; used so that mutliple
|
||||
programs can use the same discovery ports on the same network.
|
||||
*/
|
||||
const char* appProtocolName;
|
||||
|
||||
/**
|
||||
Version of the network protocol of the program using discovery.
|
||||
Used so that discovery can identify incompatible versions of
|
||||
the server.
|
||||
*/
|
||||
int appProtocolVersion;
|
||||
|
||||
/**
|
||||
Port on which the server broadcasts its identity. The client
|
||||
and server must agree on this value.
|
||||
*/
|
||||
uint16 serverBroadcastPort;
|
||||
|
||||
/**
|
||||
Port on which the client broadcasts a server request. The client
|
||||
and server must agree on this value.
|
||||
*/
|
||||
uint16 clientBroadcastPort;
|
||||
|
||||
/**
|
||||
Clients connect into this port using a reliable conduit
|
||||
to receive the advertisement from a server. The client
|
||||
doesn't look at this value; it uses whatever the server
|
||||
sends it.
|
||||
*/
|
||||
uint16 serverAdvertisementPort;
|
||||
|
||||
/**
|
||||
You can use the default G3D discovery ports as long as no other
|
||||
program with the same protocol name is using this port. You
|
||||
<B>can</B> run two different G3D discovery programs on the same
|
||||
two ports as long as they have different application protocol
|
||||
strings.
|
||||
*/
|
||||
DiscoverySettings(
|
||||
const char* _appProtocolName,
|
||||
int _appProtocolVersion,
|
||||
uint16 _serverBroadcast = 6173,
|
||||
uint16 _clientBroadcast = 6174,
|
||||
uint16 _serverAdvertisementPort = 6175) :
|
||||
appProtocolName(_appProtocolName),
|
||||
appProtocolVersion(_appProtocolVersion),
|
||||
serverBroadcastPort(_serverBroadcast),
|
||||
clientBroadcastPort(_clientBroadcast),
|
||||
serverAdvertisementPort(_serverAdvertisementPort) {}
|
||||
};
|
||||
|
||||
/**
|
||||
Make your own subclass of this advertisement. Add fields
|
||||
(e.g. numPlayers, currentScore) to increase the amount
|
||||
of information advertised.
|
||||
|
||||
Overrides must provide a default constructor.
|
||||
@deprecated See Discovery2::Settings
|
||||
*/
|
||||
class DiscoveryAdvertisement {
|
||||
public:
|
||||
|
||||
/**
|
||||
Address to connect to on the server for the actual game.
|
||||
The IP portion is ignored (the client figures out the IP
|
||||
address from the packet itself) but the port is essential.
|
||||
Note that this port must not be the discovery port.
|
||||
*/
|
||||
NetAddress address;
|
||||
|
||||
/**
|
||||
(Only used on the client)
|
||||
Time since this advertisement was updated.
|
||||
*/
|
||||
RealTime lastUpdateTime;
|
||||
|
||||
/**
|
||||
Overrides must call DiscoveryAdvertisement::serialize(b) first.
|
||||
*/
|
||||
virtual void serialize(BinaryOutput& b) const;
|
||||
|
||||
/**
|
||||
Overrides must call DiscoveryAdvertisement::deserialize(b) first.
|
||||
*/
|
||||
virtual void deserialize(BinaryInput& b);
|
||||
|
||||
/**
|
||||
An empty virtual destructor for virtual methods.
|
||||
*/
|
||||
virtual ~DiscoveryAdvertisement() {}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
Sent by servers to describe their location.
|
||||
*/
|
||||
class DiscoveryServerAddressMessage {
|
||||
public:
|
||||
|
||||
/**
|
||||
Not part of the message; these settings are used to determine
|
||||
if the correct protocol is being used.
|
||||
*/
|
||||
const DiscoverySettings* settings;
|
||||
|
||||
|
||||
/**
|
||||
Set to true if this server is running the correct protocol.
|
||||
*/
|
||||
bool correctProtocol;
|
||||
|
||||
/**
|
||||
This is set during the serialize process from the server's settings.
|
||||
If different from the client's settings the discovery system will
|
||||
classify this server as incompatible.
|
||||
*/
|
||||
int serverProtocolVersion[2];
|
||||
|
||||
Array<NetAddress> address;
|
||||
|
||||
DiscoveryServerAddressMessage() {}
|
||||
DiscoveryServerAddressMessage(const DiscoverySettings* s) : settings(s) {}
|
||||
|
||||
void serialize(BinaryOutput& b) const;
|
||||
|
||||
void deserialize(BinaryInput& b);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
Base class for DiscoveryClient and DiscoveryServer.
|
||||
*/
|
||||
class Discovery {
|
||||
public:
|
||||
|
||||
const DiscoverySettings* settings;
|
||||
|
||||
enum {
|
||||
SERVER_SHUTDOWN_MESSAGE = 2,
|
||||
SERVER_BROADCAST_MESSAGE = 3,
|
||||
CLIENT_BROADCAST_MESSAGE = 4};
|
||||
|
||||
/**
|
||||
Only called from subclasses.
|
||||
*/
|
||||
virtual void init(
|
||||
const DiscoverySettings* _settings) {
|
||||
settings = _settings;
|
||||
}
|
||||
|
||||
/**
|
||||
An empty virtual destructor for virtual methods.
|
||||
*/
|
||||
virtual ~Discovery() {}
|
||||
};
|
||||
|
||||
/** @deprecated See Discovery2::Server*/
|
||||
class DiscoveryServer : private Discovery {
|
||||
private:
|
||||
|
||||
class ShutdownMessage {
|
||||
public:
|
||||
void serialize(BinaryOutput& b) const { (void)b; }
|
||||
|
||||
void deserialize(BinaryInput& b) { (void)b; }
|
||||
};
|
||||
|
||||
/**
|
||||
For broadcast.
|
||||
*/
|
||||
LightweightConduitRef net;
|
||||
|
||||
/**
|
||||
Listen for clients wanting to hear the advertisement over
|
||||
a reliable connection.
|
||||
*/
|
||||
NetListenerRef listener;
|
||||
|
||||
DiscoveryAdvertisement* advertisement;
|
||||
|
||||
/**
|
||||
Broadcast across the lightweight conduit.
|
||||
*/
|
||||
DiscoveryServerAddressMessage addressMessage;
|
||||
|
||||
/**
|
||||
Servers periodically broadcast (unsolicited) in case
|
||||
anyone missed the previous message.
|
||||
*/
|
||||
RealTime lastBroadcast;
|
||||
|
||||
void sendAnnouncement() const;
|
||||
|
||||
void sendShutDown() const;
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
You may update the advertisement (synchronously with calling doNetwork)
|
||||
after it has been passed in. This allows a server to change the advertised
|
||||
number of players or score for a game, for example.
|
||||
|
||||
You must set the port of the @a _advertisement G3D::DiscoveryAdvertisement::address
|
||||
to the port which the G3D::NetListener for the actual program protocol (not discovery)
|
||||
is running. That field how the client knows what address to connect to using
|
||||
G3D::ReliableConduit or G3D::LightweightConduit to actually initiate communication.
|
||||
*/
|
||||
virtual void init(
|
||||
const DiscoverySettings* _settings,
|
||||
DiscoveryAdvertisement* _advertisement);
|
||||
|
||||
/** Returns the broadcast address in use.*/
|
||||
NetAddress broadcastAddress() const;
|
||||
|
||||
/**
|
||||
Returns true if this discovery server has been initialized
|
||||
and is functioning properly.
|
||||
*/
|
||||
bool ok() const;
|
||||
|
||||
/**
|
||||
Call periodically to let the server do its job.
|
||||
*/
|
||||
void doNetwork();
|
||||
|
||||
/**
|
||||
Broadcast a shutdown message.
|
||||
*/
|
||||
void cleanup();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
Used by DiscoveryClient to report servers running a different version
|
||||
of this application's protocol.
|
||||
*/
|
||||
class IncompatibleServerDescription {
|
||||
public:
|
||||
NetAddress address;
|
||||
int protocolVersion[2];
|
||||
RealTime lastUpdateTime;
|
||||
|
||||
std::string toString() const;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
Only one DiscoveryClient can be active on a given port at a time on
|
||||
a single computer.
|
||||
|
||||
AdType must be a subclass of DiscoveryAdvertisement.
|
||||
|
||||
@deprecated See Discovery2::Client
|
||||
*/
|
||||
template<class AdType>
|
||||
class DiscoveryClient : private Discovery {
|
||||
public:
|
||||
|
||||
/**
|
||||
List of servers. Do not access on a second thread while in
|
||||
doNetwork.
|
||||
*/
|
||||
Array<AdType> serverList;
|
||||
|
||||
/**
|
||||
List of servers running the same application but a different protocol.
|
||||
It is useful to show these to users to help them recognize version
|
||||
conflicts between client and server.
|
||||
Do not access on a second thread while in doNetwork.
|
||||
*/
|
||||
Array<IncompatibleServerDescription> incompatibleServerList;
|
||||
|
||||
private:
|
||||
|
||||
class BroadcastMessage {
|
||||
public:
|
||||
void serialize(BinaryOutput& b) const {}
|
||||
|
||||
void deserialize(BinaryInput& b) {}
|
||||
};
|
||||
|
||||
/**
|
||||
The client periodically checks servers to make sure they are still up
|
||||
and to update its information about them.
|
||||
*/
|
||||
RealTime lastServerCheck;
|
||||
|
||||
LightweightConduitRef net;
|
||||
|
||||
/**
|
||||
Returns an index in serverList of the server with the given address.
|
||||
Returns -1 if there is none. Only checks IP addresses.
|
||||
*/
|
||||
int findServerListIndex(const NetAddress& addr) const {
|
||||
for (int i = 0; i < serverList.size(); ++i) {
|
||||
if (addr.ip() == serverList[i].address.ip()) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if this discovery client has been initialized
|
||||
and is functioning properly.
|
||||
*/
|
||||
bool ok() const {
|
||||
return net->ok();
|
||||
}
|
||||
|
||||
/**
|
||||
Adds a server to the incompatible list if it is not already there.
|
||||
*/
|
||||
void addToIncompatibleList(const NetAddress& addr, uint32 p0, uint32 p1) {
|
||||
const RealTime now = System::time();
|
||||
|
||||
bool alreadyHere = false;
|
||||
|
||||
// Incorrect protocol; add to the incompatible list
|
||||
for (int i = 0; i < incompatibleServerList.size(); ++i) {
|
||||
IncompatibleServerDescription& server = incompatibleServerList[i];
|
||||
|
||||
if (server.address == addr) {
|
||||
server.lastUpdateTime = now;
|
||||
alreadyHere = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (! alreadyHere) {
|
||||
IncompatibleServerDescription server;
|
||||
|
||||
server.lastUpdateTime = now;
|
||||
server.address = addr;
|
||||
server.protocolVersion[0] = p0;
|
||||
server.protocolVersion[1] = p1;
|
||||
|
||||
incompatibleServerList.append(server);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Connects to the specified server, reads its advertisement,
|
||||
and adds it to the active server list. Returns true if the server
|
||||
can be reached.
|
||||
*/
|
||||
bool readAdvertisement(const NetAddress& address) {
|
||||
std::string hostname = address.toString();
|
||||
|
||||
RealTime TIMEOUT = 2.0;
|
||||
|
||||
ReliableConduitRef server = ReliableConduit::create(address);
|
||||
|
||||
if (! server->ok()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
AdType advertisement;
|
||||
|
||||
// Read the advertisement
|
||||
RealTime stopWaiting = System::time() + TIMEOUT;
|
||||
bool timedOut = false;
|
||||
|
||||
while (! server->messageWaiting() && ! timedOut && server->ok()) {
|
||||
System::sleep(0.1);
|
||||
timedOut = (System::time() > stopWaiting);
|
||||
}
|
||||
|
||||
if (timedOut) {
|
||||
Log::common()->printf("Discovery: Timed out while reading advertisment from %s\n",
|
||||
hostname.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
if (! server->ok()) {
|
||||
Log::common()->printf("Discovery: Server %s dropped connection\n", hostname.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
// Read the advertisement
|
||||
debugAssert(server->messageWaiting());
|
||||
if (! server->receive(advertisement)) {
|
||||
Log::common()->printf("Discovery: Server %s failed to send advertisement\n", hostname.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
// Update existing server info or create a new entry
|
||||
int index = findServerListIndex(address);
|
||||
if (index == -1) {
|
||||
index = serverList.size();
|
||||
serverList.resize(index + 1);
|
||||
}
|
||||
|
||||
// Update element index
|
||||
advertisement.address = address;
|
||||
serverList[index] = advertisement;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
Remove this address from our list if we previously
|
||||
had a server there.
|
||||
*/
|
||||
void removeServer(const NetAddress& address) {
|
||||
int index = findServerListIndex(address);
|
||||
if (index > -1) {
|
||||
serverList.fastRemove(index);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Tries to connect to the server through the addresses in the array.
|
||||
*/
|
||||
void addToServerList(const Array<NetAddress>& addressArray) {
|
||||
// Try to connect to each address listed
|
||||
for (int a = addressArray.size() - 1; a >= 0; --a) {
|
||||
const NetAddress& address = addressArray[a];
|
||||
|
||||
if (readAdvertisement(address)) {
|
||||
// We've connected to the server
|
||||
break;
|
||||
} else {
|
||||
removeServer(address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void checkRandomServer() {
|
||||
if (serverList.size() >= 1) {
|
||||
int index = iRandom(0, serverList.size() - 1);
|
||||
|
||||
Array<NetAddress> address;
|
||||
address.append(serverList[index].address);
|
||||
|
||||
// Remove this server
|
||||
serverList.fastRemove(index);
|
||||
|
||||
// Add it back with new info (or leave it removed if no response)
|
||||
addToServerList(address);
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
void init(
|
||||
const DiscoverySettings* _settings) {
|
||||
|
||||
Discovery::init(_settings);
|
||||
|
||||
lastServerCheck = System::time();
|
||||
|
||||
net = LightweightConduit::create(settings->serverBroadcastPort, true, true);
|
||||
|
||||
// Send announcement
|
||||
NetAddress broadcast(NetworkDevice::instance()->broadcastAddressArray()[0],
|
||||
settings->clientBroadcastPort);
|
||||
BroadcastMessage tmp;
|
||||
net->send(broadcast, CLIENT_BROADCAST_MESSAGE, tmp);
|
||||
}
|
||||
|
||||
/** Shut down the discovery client. */
|
||||
void cleanup() {
|
||||
net = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
Call this regularly (several times per second) to
|
||||
update the server list. Not threadsafe-- you must not touch
|
||||
the server list while this is running. This will not block.
|
||||
*/
|
||||
void doNetwork() {
|
||||
if (net->messageWaiting()) {
|
||||
NetAddress sender;
|
||||
|
||||
switch (net->waitingMessageType()) {
|
||||
case SERVER_SHUTDOWN_MESSAGE:
|
||||
// Remove the server
|
||||
net->receive(sender);
|
||||
removeServer(sender);
|
||||
break;
|
||||
|
||||
case SERVER_BROADCAST_MESSAGE:
|
||||
// Check the G3D protocol and the network protocol, then read the ad
|
||||
DiscoveryServerAddressMessage msg(settings);
|
||||
net->receive(sender, msg);
|
||||
|
||||
if (msg.correctProtocol && (msg.address.size() > 0)) {
|
||||
// Add the actual return address as the first one to be tried.
|
||||
msg.address.append(NetAddress(sender.ip(), msg.address[0].port()));
|
||||
|
||||
addToServerList(msg.address);
|
||||
|
||||
} else {
|
||||
|
||||
addToIncompatibleList(
|
||||
sender,
|
||||
msg.serverProtocolVersion[0],
|
||||
msg.serverProtocolVersion[1]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Periodically re-check servers in the list to see if they crashed
|
||||
// (if they shut down, they should have broadcast a shut down message).
|
||||
RealTime now = System::time();
|
||||
const RealTime UPDATE_TIME_INTERVAL = 30;
|
||||
|
||||
if (now > lastServerCheck + UPDATE_TIME_INTERVAL) {
|
||||
lastServerCheck = now;
|
||||
checkRandomServer();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,26 @@
|
||||
/**
|
||||
@file EqualsTrait.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2008-10-01
|
||||
@edited 2008-10-01
|
||||
Copyright 2000-2008, 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<typename Key> struct EqualsTrait {
|
||||
static bool equals(const Key& a, const Key& b) {
|
||||
return a == b;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
/**
|
||||
@file graphics3D.h
|
||||
|
||||
This header includes all of the graphics3D libraries in
|
||||
appropriate namespaces.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-08-25
|
||||
@edited 2008-11-01
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_GRAPHICS3D_H
|
||||
#define G3D_GRAPHICS3D_H
|
||||
|
||||
#define NOMINMAX 1
|
||||
#ifdef min
|
||||
#undef min
|
||||
#endif
|
||||
#ifdef max
|
||||
#undef max
|
||||
#endif
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.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/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/G3DGameUnits.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/uint128.h"
|
||||
#include "G3D/fileutils.h"
|
||||
#include "G3D/ReferenceCount.h"
|
||||
|
||||
template<class T> struct HashTrait< G3D::ReferenceCountedPointer<T> > {
|
||||
static size_t hashCode(G3D::ReferenceCountedPointer<T> key) { return reinterpret_cast<size_t>( key.pointer() ); }
|
||||
};
|
||||
|
||||
#include "G3D/GImage.h"
|
||||
#include "G3D/CollisionDetection.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/Discovery.h"
|
||||
#include "G3D/MeshAlg.h"
|
||||
#include "G3D/vectorMath.h"
|
||||
#include "G3D/Rect2D.h"
|
||||
#include "G3D/GCamera.h"
|
||||
#include "G3D/GLight.h"
|
||||
#include "G3D/AABSPTree.h"
|
||||
#include "G3D/PointAABSPTree.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/AnyVal.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
|
||||
|
||||
+26
@@ -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 <G3D.h> separately.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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
|
||||
@@ -0,0 +1,44 @@
|
||||
/**
|
||||
@file G3DGameUnits.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@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};
|
||||
|
||||
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};
|
||||
|
||||
#define CENTIMETER (0.01)
|
||||
#define DECIMETER (0.1)
|
||||
|
||||
/**
|
||||
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: <CODE>toSeconds(10, 00, AM)</CODE>
|
||||
*/
|
||||
SimTime toSeconds(int hour, int minute, double seconds, AMPM ap);
|
||||
SimTime toSeconds(int hour, int minute, AMPM ap);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+294
@@ -0,0 +1,294 @@
|
||||
/**
|
||||
@file GCamera.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2005-07-20
|
||||
@edited 2007-07-24
|
||||
*/
|
||||
|
||||
#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;
|
||||
|
||||
/**
|
||||
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::viewport().
|
||||
*/
|
||||
class GCamera {
|
||||
|
||||
public:
|
||||
/**
|
||||
Stores the direction of the field of view
|
||||
*/
|
||||
enum FOVDirection {HORIZONTAL, VERTICAL};
|
||||
|
||||
private:
|
||||
|
||||
|
||||
/** 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:
|
||||
|
||||
class Frustum {
|
||||
public:
|
||||
class Face {
|
||||
public:
|
||||
/** Counter clockwise indices into vertexPos */
|
||||
int vertexIndex[4];
|
||||
|
||||
/** The plane containing the face. */
|
||||
Plane plane;
|
||||
};
|
||||
|
||||
/** The vertices, in homogeneous space. If w == 0,
|
||||
a vertex is at infinity. */
|
||||
Array<Vector4> vertexPos;
|
||||
|
||||
/** The faces in the frustum. When the
|
||||
far plane is at infinity, there are 5 faces,
|
||||
otherwise there are 6. The faces are in the order
|
||||
N,R,L,B,T,[F].
|
||||
*/
|
||||
Array<Face> faceArray;
|
||||
};
|
||||
|
||||
GCamera();
|
||||
|
||||
virtual ~GCamera();
|
||||
|
||||
/** Returns the current coordinate frame */
|
||||
const CoordinateFrame& coordinateFrame() const {
|
||||
return m_cframe;
|
||||
}
|
||||
|
||||
/** 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 P equal to the camera's projection matrix */
|
||||
void getProjectUnitMatrix(const Rect2D& viewport, Matrix4& P) const;
|
||||
|
||||
/** Converts projected points from OpenGL standards
|
||||
(-1, 1) to normal 3D coordinate standards (0, 1) */
|
||||
Vector3 convertFromUnitToNormal(const Vector3& in, const Rect2D& viewport) const;
|
||||
|
||||
/**
|
||||
Sets the vertical field of view, in radians. The
|
||||
initial angle is toRadians(55). Must specify the direction of the angle
|
||||
*/
|
||||
void setFieldOfView(float angle, FOVDirection direction);
|
||||
|
||||
/** Returns the current field of view angle 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 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.
|
||||
*/
|
||||
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
|
||||
world space area at the given z value (z must be negative).
|
||||
*/
|
||||
float worldToScreenSpaceArea(float area, float z, const class Rect2D& viewport) const;
|
||||
|
||||
/**
|
||||
Returns the world space 3D viewport corners. These
|
||||
are at the near clipping plane. The corners are constructed
|
||||
from the nearPlaneZ, viewportWidth, and viewportHeight.
|
||||
"left" and "right" are from the GCamera's perspective.
|
||||
*/
|
||||
void getNearViewportCorners(const class Rect2D& viewport,
|
||||
Vector3& outUR, Vector3& outUL,
|
||||
Vector3& outLL, Vector3& outLR) 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
|
||||
(x, y) on the image plane. The pixel x and y axes are opposite
|
||||
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 nearPlaneZ() const {
|
||||
return m_nearPlaneZ;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a negative z-value.
|
||||
*/
|
||||
inline float farPlaneZ() const {
|
||||
return m_farPlaneZ;
|
||||
}
|
||||
|
||||
/**
|
||||
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 camera space width of the viewport at the near plane.
|
||||
*/
|
||||
float viewportWidth(const class Rect2D& viewport) 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 <B>into</B> 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<Plane>& outClip) const;
|
||||
|
||||
/**
|
||||
Returns the world space view frustum, which is a truncated pyramid describing
|
||||
the volume of space seen by this camera.
|
||||
*/
|
||||
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
|
||||
|
||||
#endif
|
||||
+550
@@ -0,0 +1,550 @@
|
||||
/**
|
||||
@file GImage.h
|
||||
|
||||
See G3D::GImage for details.
|
||||
|
||||
@cite JPEG compress/decompressor is the <A HREF="http://www.ijg.org/files/">IJG library</A>, 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 <A HREF="mailto:[email protected]">mailto:[email protected]</A> at <A HREF="ftp://ftp.flipcode.com/cotd/LoadPicture.txt">ftp://ftp.flipcode.com/cotd/LoadPicture.txt</A>
|
||||
@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 <A HREF="http://www.libpng.org/pub/png/libpng.html">libpng library</A>, used in accordance with their license.
|
||||
@cite PPM code by Morgan McGuire based on http://netpbm.sourceforge.net/doc/ppm.html
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2002-05-27
|
||||
@edited 2007-01-31
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
|
||||
*/
|
||||
|
||||
#ifndef G3D_GIMAGE_H
|
||||
#define G3D_GIMAGE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <string>
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/stringutils.h"
|
||||
#include "G3D/Color1uint8.h"
|
||||
#include "G3D/Color3uint8.h"
|
||||
#include "G3D/Color4uint8.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).
|
||||
8-bit paletted PCX, 24-bit PCX, and ICO are supported for decoding only.
|
||||
|
||||
Sample usage:
|
||||
|
||||
<PRE>
|
||||
#include "graphics3D.h"
|
||||
|
||||
// Loading from disk:
|
||||
G3D::GImage im1 = G3D::GImage("test.jpg");
|
||||
|
||||
// Loading from memory:
|
||||
G3D::GImage im2 = G3D::GImage(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 = G3D::GImage(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");
|
||||
</PRE>
|
||||
|
||||
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:
|
||||
uint8* _byte;
|
||||
|
||||
public:
|
||||
|
||||
class Error {
|
||||
public:
|
||||
Error(
|
||||
const std::string& reason,
|
||||
const std::string& filename = "") :
|
||||
reason(reason), filename(filename) {}
|
||||
|
||||
std::string reason;
|
||||
std::string filename;
|
||||
};
|
||||
|
||||
enum Format {JPEG, BMP, TGA, PCX, ICO, PNG, PPM_ASCII, PPM, AUTODETECT, UNKNOWN};
|
||||
|
||||
int width;
|
||||
int height;
|
||||
|
||||
/**
|
||||
The number of channels; either 3 (RGB) or 4 (RGBA)
|
||||
*/
|
||||
int channels;
|
||||
|
||||
inline const uint8* byte() const {
|
||||
return _byte;
|
||||
}
|
||||
|
||||
/** Returns a pointer to the upper left pixel
|
||||
as Color3uint8.
|
||||
*/
|
||||
inline const Color3uint8* pixel3() const {
|
||||
debugAssertM(channels == 3, format("Tried to call GImage::pixel3 on an image with %d channels", channels));
|
||||
return (Color3uint8*)_byte;
|
||||
}
|
||||
|
||||
/** Returns a pointer to the upper left pixel
|
||||
as Color4uint8.
|
||||
*/
|
||||
inline const Color4uint8* pixel4() const {
|
||||
debugAssertM(channels == 4, format("Tried to call GImage::pixel4 on an image with %d channels", channels));
|
||||
return (Color4uint8*)_byte;
|
||||
}
|
||||
|
||||
inline const Color1uint8* pixel1() const {
|
||||
debugAssertM(channels == 1, format("Tried to call GImage::pixel1 on an image with %d channels", channels));
|
||||
return (Color1uint8*)_byte;
|
||||
}
|
||||
|
||||
inline Color1uint8* pixel1() {
|
||||
debugAssertM(channels == 1, format("Tried to call GImage::pixel1 on an image with %d channels", channels));
|
||||
return (Color1uint8*)_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 < width);
|
||||
debugAssert(y >= 0 && y < height);
|
||||
return pixel1()[x + y * 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 < width);
|
||||
debugAssert(y >= 0 && y < height);
|
||||
return pixel1()[x + y * 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 < width);
|
||||
debugAssert(y >= 0 && y < height);
|
||||
return pixel3()[x + y * width];
|
||||
}
|
||||
|
||||
inline Color3uint8& pixel3(int x, int y) {
|
||||
debugAssert(x >= 0 && x < width);
|
||||
debugAssert(y >= 0 && y < height);
|
||||
return pixel3()[x + y * 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 < width);
|
||||
debugAssert(y >= 0 && y < height);
|
||||
return pixel4()[x + y * width];
|
||||
}
|
||||
|
||||
inline Color4uint8& pixel4(int x, int y) {
|
||||
debugAssert(x >= 0 && x < width);
|
||||
debugAssert(y >= 0 && y < height);
|
||||
return pixel4()[x + y * width];
|
||||
}
|
||||
|
||||
inline uint8* byte() {
|
||||
return _byte;
|
||||
}
|
||||
|
||||
inline Color3uint8* pixel3() {
|
||||
debugAssert(channels == 3);
|
||||
return (Color3uint8*)_byte;
|
||||
}
|
||||
|
||||
inline Color4uint8* pixel4() {
|
||||
debugAssert(channels == 4);
|
||||
return (Color4uint8*)_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:
|
||||
static Format resolveFormat(const std::string& filename);
|
||||
|
||||
GImage() {
|
||||
width = height = channels = 0;
|
||||
_byte = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
Load an encoded image from disk and decode it.
|
||||
Throws GImage::Error if something goes wrong.
|
||||
*/
|
||||
GImage(
|
||||
const std::string& filename,
|
||||
Format format = AUTODETECT);
|
||||
|
||||
/**
|
||||
Decodes an image stored in a buffer.
|
||||
*/
|
||||
GImage(
|
||||
const unsigned char*data,
|
||||
int length,
|
||||
Format format = AUTODETECT);
|
||||
|
||||
/**
|
||||
Create an empty image of the given size.
|
||||
*/
|
||||
GImage(
|
||||
int width,
|
||||
int height,
|
||||
int channels = 3);
|
||||
|
||||
GImage(
|
||||
const GImage& other);
|
||||
|
||||
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;
|
||||
|
||||
GImage G3D_DEPRECATED insertRedAsAlpha(const GImage& alpha) 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;
|
||||
|
||||
GImage G3D_DEPRECATED stripAlpha() const;
|
||||
|
||||
/**
|
||||
Loads an image from disk (clearing the old one first).
|
||||
*/
|
||||
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 (width x height) with the
|
||||
number of channels specified. All data is set to 0 (black).
|
||||
*/
|
||||
void resize(int width, int height, int channels);
|
||||
|
||||
|
||||
/**
|
||||
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.
|
||||
*/
|
||||
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.
|
||||
@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);
|
||||
|
||||
/** 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:
|
||||
<PRE>
|
||||
GImage normal;
|
||||
computeNormalMap(GImage(filename), normal);
|
||||
return Texture::fromGImage(filename, normal);
|
||||
</PRE>
|
||||
|
||||
@param lowPassBump If true, a 9x9 filter of 1's is used to low-pass filter the elevations,
|
||||
which produces better results for parallax mapping.
|
||||
|
||||
@param scaleHeightByNz After computing normals, scale the height by |N.z|, a trick that
|
||||
reduces texture swim in steep areas for parallax mapping.
|
||||
|
||||
@param whiteHeightInPixels How high should the brightest input value be considered for purposes
|
||||
of normal computation, compared to the horizontal and vertical size of a pixel.
|
||||
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 special (default) value of -1 means scale the effective white height so that it is equal
|
||||
to the larger spatial dimension.
|
||||
*/
|
||||
static void computeNormalMap(
|
||||
const class GImage& bump,
|
||||
class GImage& normal,
|
||||
float whiteHeightInPixels = -1.0f,
|
||||
bool lowPassBump = false,
|
||||
bool scaleHeightByNz = false);
|
||||
|
||||
static void computeNormalMap(
|
||||
int width,
|
||||
int height,
|
||||
int channels,
|
||||
const uint8* src,
|
||||
GImage& normal,
|
||||
float whiteHeightInPixels,
|
||||
bool lowPassBump,
|
||||
bool scaleHeightByNz);
|
||||
|
||||
/**
|
||||
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
|
||||
+72
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
@file GLight.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-11-12
|
||||
@edited 2006-02-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 {
|
||||
|
||||
/**
|
||||
A light representation that closely follows the OpenGL light format.
|
||||
*/
|
||||
class GLight {
|
||||
public:
|
||||
/** World space position (for a directional light, w = 0 */
|
||||
Vector4 position;
|
||||
|
||||
/** Direction in which the light faces, if a spot light. This is the "look vector" of the light source. */
|
||||
Vector3 spotDirection;
|
||||
|
||||
/** In <B>degrees</B>. 180 = no cutoff (point/dir) >90 = spot light */
|
||||
float spotCutoff;
|
||||
|
||||
/** 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();
|
||||
|
||||
/** @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.
|
||||
*/
|
||||
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;
|
||||
|
||||
bool operator==(const GLight& other) const;
|
||||
bool operator!=(const GLight& other) const;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
#endif
|
||||
|
||||
+169
@@ -0,0 +1,169 @@
|
||||
/**
|
||||
@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 <string>
|
||||
|
||||
#ifndef G3D_WIN32
|
||||
# include <pthread.h>
|
||||
# include <signal.h>
|
||||
#endif
|
||||
|
||||
|
||||
namespace G3D {
|
||||
|
||||
typedef ReferenceCountedPointer<class GThread> 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::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;
|
||||
|
||||
public:
|
||||
|
||||
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);
|
||||
|
||||
/** @deprecated use overload that accepts void* param */
|
||||
static GThreadRef create(const std::string& name, void (*proc)());
|
||||
|
||||
/** 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).*/
|
||||
bool start();
|
||||
|
||||
/** 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;
|
||||
}
|
||||
|
||||
/** Overriden by the thread implementor */
|
||||
virtual void threadMain() = 0;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
Mutual exclusion lock used for synchronization.
|
||||
@sa G3D::GThread, G3D::AtomicInt32
|
||||
*/
|
||||
class GMutex {
|
||||
private:
|
||||
# ifdef G3D_WIN32
|
||||
CRITICAL_SECTION m_handle;
|
||||
# else
|
||||
pthread_mutex_t m_handle;
|
||||
# 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();
|
||||
|
||||
/** 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();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
#endif //G3D_GTHREAD_H
|
||||
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
@file GUniqueID.h
|
||||
@author Morgan McGuire, [email protected]
|
||||
*/
|
||||
#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<class G3D::GUniqueID> {
|
||||
static size_t hashCode(G3D::GUniqueID id) { return (size_t)(G3D::uint64)id; }
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
@file HashTrait.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2008-10-01
|
||||
@edited 2008-10-01
|
||||
Copyright 2000-2008, 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 <typename T> struct HashTrait{};
|
||||
|
||||
template <typename T> struct HashTrait<T*> {
|
||||
static size_t hashCode(const void* k) { return reinterpret_cast<size_t>(k); }
|
||||
};
|
||||
|
||||
template <> struct HashTrait <int> {
|
||||
static size_t hashCode(int k) { return static_cast<size_t>(k); }
|
||||
};
|
||||
|
||||
template <> struct HashTrait <G3D::uint32> {
|
||||
static size_t hashCode(G3D::uint32 k) { return static_cast<size_t>(k); }
|
||||
};
|
||||
|
||||
template <> struct HashTrait <G3D::uint64> {
|
||||
static size_t hashCode(G3D::uint64 k) { return static_cast<size_t>(k); }
|
||||
};
|
||||
|
||||
template <> struct HashTrait <std::string> {
|
||||
static size_t hashCode(const std::string& k) { return static_cast<size_t>(G3D::Crypto::crc32(k.c_str(), k.size())); }
|
||||
};
|
||||
|
||||
template <> struct HashTrait<G3D::uint128> {
|
||||
// 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(0xCF470AAC6CB293D2LL, 0xF52F88BF32307F8FLL);
|
||||
|
||||
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<size_t>((foldedHash >> 32) ^ (foldedHash & 0xFFFFFFFF));
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
+79
@@ -0,0 +1,79 @@
|
||||
/**
|
||||
@file Image1.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<class Image1> Image1Ref;
|
||||
|
||||
/**
|
||||
Luminance image with 32-bit floating point storage.
|
||||
|
||||
See also G3D::Image1uint8, G3D::GImage.
|
||||
*/
|
||||
class Image1 : public Map2D<Color1, Color1> {
|
||||
public:
|
||||
|
||||
typedef Image1 Type;
|
||||
typedef Image1Ref Ref;
|
||||
|
||||
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<class Image1uint8>& 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
|
||||
@@ -0,0 +1,80 @@
|
||||
/**
|
||||
@file Image1uint8.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<class Image1uint8> Image1uint8Ref;
|
||||
|
||||
/**
|
||||
Compact storage for luminance 8-bit images.
|
||||
|
||||
See also G3D::Image3, G3D::GImage
|
||||
*/
|
||||
class Image1uint8 : public Map2D<Color1uint8, Color1> {
|
||||
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<class Image1>& im);
|
||||
static Ref fromImage3uint8(const ReferenceCountedPointer<class Image3uint8>& 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
|
||||
+79
@@ -0,0 +1,79 @@
|
||||
/**
|
||||
@file Image3.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<class Image3> Image3Ref;
|
||||
|
||||
/**
|
||||
RGB image with 32-bit floating point storage for each channel.
|
||||
|
||||
See also G3D::Image3uint8, G3D::GImage.
|
||||
*/
|
||||
class Image3 : public Map2D<Color3, Color3> {
|
||||
public:
|
||||
|
||||
typedef Image3 Type;
|
||||
typedef Image3Ref Ref;
|
||||
|
||||
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<class Image3uint8>& 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
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
@file Image3uint8.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<class Image3uint8> Image3uint8Ref;
|
||||
|
||||
/**
|
||||
Compact storage for RGB 8-bit per channel images.
|
||||
|
||||
See also G3D::Image3, G3D::GImage
|
||||
*/
|
||||
class Image3uint8 : public Map2D<Color3uint8, Color3> {
|
||||
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<class Image3>& im);
|
||||
static Ref fromImage1uint8(const ReferenceCountedPointer<class Image1uint8>& 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<class Image1uint8> getChannel(int c) const;
|
||||
};
|
||||
|
||||
} // G3D
|
||||
|
||||
#endif
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
/**
|
||||
@file Image4.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<class Image4> Image4Ref;
|
||||
|
||||
/**
|
||||
RGBA image with 32-bit floating point storage for each channel.
|
||||
|
||||
Whenever a method needs to convert from RGB to ARGB, A=1 is assumed.
|
||||
|
||||
See also G3D::Image4uint8, G3D::GImage.
|
||||
*/
|
||||
class Image4 : public Map2D<Color4, Color4> {
|
||||
public:
|
||||
|
||||
typedef Image4 Type;
|
||||
typedef Image4Ref Ref;
|
||||
|
||||
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<class Image4uint8>& 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
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
@file Image4uint8.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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<class Image4uint8> Image4uint8Ref;
|
||||
|
||||
/**
|
||||
Compact storage for RGBA 8-bit per channel images.
|
||||
|
||||
See also G3D::Image4, G3D::GImage
|
||||
*/
|
||||
class Image4uint8 : public Map2D<Color4uint8, Color4> {
|
||||
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<class Image4>& 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<class Image1uint8> getChannel(int c) const;
|
||||
};
|
||||
|
||||
} // G3D
|
||||
|
||||
#endif
|
||||
+362
@@ -0,0 +1,362 @@
|
||||
/**
|
||||
@file ImageFormat.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-05-23
|
||||
@edited 2008-07-17
|
||||
*/
|
||||
|
||||
#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_ARGB8,
|
||||
CODE_BGR8,
|
||||
|
||||
CODE_RGBA8,
|
||||
CODE_RGBA16,
|
||||
CODE_RGBA16F,
|
||||
CODE_RGBA32F,
|
||||
|
||||
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_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
|
||||
};
|
||||
|
||||
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 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 texture.*/
|
||||
std::string name() const;
|
||||
|
||||
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* 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* RGB_DXT1();
|
||||
|
||||
static const ImageFormat* RGBA_DXT1();
|
||||
|
||||
static const ImageFormat* RGBA_DXT3();
|
||||
|
||||
static const ImageFormat* RGBA_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<const void*>& srcBytes, int srcWidth, int srcHeight, const ImageFormat* srcFormat, int srcRowPadBits,
|
||||
const Array<void*>& 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<const G3D::ImageFormat*> {
|
||||
static size_t hashCode(const G3D::ImageFormat* key) { return reinterpret_cast<size_t>(key); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
+105
@@ -0,0 +1,105 @@
|
||||
/**
|
||||
@file Line.h
|
||||
|
||||
Line class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2006-02-28
|
||||
*/
|
||||
|
||||
#ifndef G3D_LINE_H
|
||||
#define G3D_LINE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class Plane;
|
||||
|
||||
/**
|
||||
An infinite 3D line.
|
||||
*/
|
||||
class Line {
|
||||
protected:
|
||||
|
||||
Vector3 _point;
|
||||
Vector3 _direction;
|
||||
|
||||
Line(const Vector3& point, const Vector3& direction) {
|
||||
_point = point;
|
||||
_direction = direction.direction();
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/** Undefined (provided for creating Array<Line> only) */
|
||||
inline Line() {}
|
||||
|
||||
Line(class BinaryInput& b);
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
virtual ~Line() {}
|
||||
|
||||
/**
|
||||
Constructs a line from two (not equal) points.
|
||||
*/
|
||||
static Line fromTwoPoints(const Vector3 &point1, const Vector3 &point2) {
|
||||
return Line(point1, point2 - point1);
|
||||
}
|
||||
|
||||
/**
|
||||
Creates a line from a point and a (nonzero) direction.
|
||||
*/
|
||||
static Line fromPointAndDirection(const Vector3& point, const Vector3& direction) {
|
||||
return Line(point, direction);
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the closest point on the line to point.
|
||||
*/
|
||||
Vector3 closestPoint(const Vector3& pt) const;
|
||||
|
||||
/**
|
||||
Returns the distance between point and the line
|
||||
*/
|
||||
double distance(const Vector3& point) const {
|
||||
return (closestPoint(point) - point).magnitude();
|
||||
}
|
||||
|
||||
/** Returns a point on the line */
|
||||
Vector3 point() const;
|
||||
|
||||
/** Returns the direction (or negative direction) of the line */
|
||||
Vector3 direction() const;
|
||||
|
||||
/**
|
||||
Returns the point where the line and plane intersect. If there
|
||||
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
|
||||
|
||||
|
||||
#endif
|
||||
+115
@@ -0,0 +1,115 @@
|
||||
/**
|
||||
@file LineSegment.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@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
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
/**
|
||||
@file Log.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@cite Backtrace by Aaron Orenstein
|
||||
@created 2001-08-04
|
||||
@edited 2005-11-04
|
||||
*/
|
||||
|
||||
#ifndef G3D_LOG_H
|
||||
#define G3D_LOG_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
#include "G3D/platform.h"
|
||||
|
||||
#ifndef G3D_WIN32
|
||||
#include <stdarg.h>
|
||||
#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, ...);
|
||||
|
||||
/**
|
||||
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;
|
||||
|
||||
/**
|
||||
Prints the time & stack trace.
|
||||
*/
|
||||
void printHeader();
|
||||
|
||||
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;
|
||||
|
||||
static Log* common();
|
||||
|
||||
static std::string getCommonLogFilename();
|
||||
|
||||
void print(const std::string& s);
|
||||
|
||||
|
||||
void println(const std::string& s);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+665
@@ -0,0 +1,665 @@
|
||||
/**
|
||||
@file Map2D.h
|
||||
|
||||
More flexible support than provided by G3D::GImage.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2004-10-10
|
||||
@edited 2007-07-18
|
||||
*/
|
||||
#ifndef G3D_MAP2D_H
|
||||
#define G3D_MAP2D_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Array.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 <string>
|
||||
|
||||
namespace G3D {
|
||||
namespace _internal {
|
||||
|
||||
/** The default compute type for a type is the type itself. */
|
||||
template<typename Storage> 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<Color3> that supports image loading and saving and conversion to Texture.
|
||||
|
||||
G3D::Image4 - A subclass of Map2D<Color4> that supports image loading and saving and conversion to Texture.
|
||||
|
||||
G3D::Image3uint8 - A subclass of Map2D<Color3uint8> that supports image loading and saving and conversion to Texture.
|
||||
|
||||
G3D::Image4uint8 - A subclass of Map2D<Color4uint8> 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
|
||||
<code>Map2D<double, uint8></code>. By default, the computation type is:
|
||||
|
||||
<pre>
|
||||
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
|
||||
</pre>
|
||||
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:
|
||||
|
||||
<code>im->set(x, y, 7);</code> or
|
||||
<code>im->get(x, y) = 7;</code>
|
||||
|
||||
Read value:
|
||||
|
||||
<code>int c = im(x, y);</code>
|
||||
|
||||
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, [email protected]
|
||||
*/
|
||||
template< typename Storage,
|
||||
typename Compute = typename G3D::_internal::_GetComputeType<Storage>::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<Storage, Compute> Type;
|
||||
typedef ReferenceCountedPointer<Map2D> 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<Storage> 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<Storage>& getArray() {
|
||||
return data;
|
||||
}
|
||||
|
||||
|
||||
const Array<Storage>& 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<Type*>(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<Storage&>(const_cast<const Type*>(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<Storage&>(const_cast<const Type*>(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<Storage&>(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 <code>image->nearest(x, y) == image(x, y)</code>
|
||||
*/
|
||||
inline Compute nearest(float x, float y, WrapMode wrap) const {
|
||||
return Compute(get(iRound(x), iRound(y), 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 {
|
||||
int i = iFloor(x);
|
||||
int j = iFloor(y);
|
||||
|
||||
float fX = x - i;
|
||||
float fY = y - j;
|
||||
|
||||
// Horizontal interpolation, first row
|
||||
Compute t0(get(i, j, wrap));
|
||||
Compute t1(get(i + 1, j, wrap));
|
||||
Compute A = lerp(t0, t1, fX);
|
||||
|
||||
// Horizontal interpolation, second row
|
||||
Compute t2(get(i, j + 1, wrap));
|
||||
Compute t3(get(i + 1, j + 1, wrap));
|
||||
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;
|
||||
|
||||
// 'static' prevents constructors from being called
|
||||
// every time through this loop.
|
||||
static Compute vsample[4];
|
||||
for (int v = 0; v < 4; ++v) {
|
||||
|
||||
// Horizontal interpolation
|
||||
static 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
|
||||
+634
@@ -0,0 +1,634 @@
|
||||
/**
|
||||
@file Matrix.h
|
||||
@author Morgan McGuire, [email protected]
|
||||
|
||||
@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:
|
||||
|
||||
<PRE>
|
||||
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.
|
||||
|
||||
</PRE>
|
||||
|
||||
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,
|
||||
<CODE>A = B.transpose()</CODE> can also be invoked as <CODE>B.transpose(A)</CODE>.
|
||||
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<double> and Matrix<ComplexFloat>.
|
||||
|
||||
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<Impl> 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<class S>
|
||||
static Matrix fromDiagonal(const Array<S>& 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<SUP>-1</SUP> computed using the Gauss-Jordan algorithm,
|
||||
for square matrices.
|
||||
Run time is <I>O(R<sup>3</sup>)</I>, where <I>R</i> 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();
|
||||
}
|
||||
|
||||
/**
|
||||
A<SUP>T</SUP>
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
(A<SUP>T</SUP>A)<SUP>-1</SUP>A<SUP>T</SUP>) 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;
|
||||
|
||||
/**
|
||||
(A<SUP>T</SUP>A)<SUP>-1</SUP>A<SUP>T</SUP>) 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 <I>O(C<sup>2</sup>*R)</I>.
|
||||
|
||||
@param sort If true (default), the singular values
|
||||
are arranged so that D is sorted from largest to smallest.
|
||||
*/
|
||||
void svd(Matrix& U, Array<T>& 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
|
||||
|
||||
+69
@@ -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
|
||||
+323
@@ -0,0 +1,323 @@
|
||||
/**
|
||||
@file Matrix3.h
|
||||
|
||||
3x3 matrix class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@cite Portions based on Dave Eberly's Magic Software Library at <A HREF="http://www.magic-software.com">http://www.magic-software.com</A>
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2006-04-05
|
||||
*/
|
||||
|
||||
#ifndef G3D_MATRIX3_H
|
||||
#define G3D_MATRIX3_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector4.h"
|
||||
#include "G3D/debugAssert.h"
|
||||
|
||||
#include <cstring>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
3x3 matrix. Do not subclass.
|
||||
*/
|
||||
class Matrix3 {
|
||||
private:
|
||||
|
||||
float elt[3][3];
|
||||
|
||||
// Hidden operators
|
||||
bool operator<(const Matrix3&) const;
|
||||
bool operator>(const Matrix3&) const;
|
||||
bool operator<=(const Matrix3&) const;
|
||||
bool operator>=(const Matrix3&) const;
|
||||
|
||||
public:
|
||||
|
||||
/** 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;
|
||||
|
||||
/** 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);
|
||||
|
||||
/**
|
||||
Sets all elements.
|
||||
*/
|
||||
void set(float fEntry00, float fEntry01, float fEntry02,
|
||||
float fEntry10, float fEntry11, float fEntry12,
|
||||
float fEntry20, float fEntry21, float fEntry22);
|
||||
|
||||
/**
|
||||
* member access, allows use of construct mat[r][c]
|
||||
*/
|
||||
inline float* operator[] (int iRow) {
|
||||
debugAssert(iRow >= 0);
|
||||
debugAssert(iRow < 3);
|
||||
return (float*)&elt[iRow][0];
|
||||
}
|
||||
|
||||
inline const float* operator[] (int iRow) const {
|
||||
debugAssert(iRow >= 0);
|
||||
debugAssert(iRow < 3);
|
||||
return (const float*)&elt[iRow][0];
|
||||
}
|
||||
|
||||
inline operator float* () {
|
||||
return (float*)&elt[0][0];
|
||||
}
|
||||
|
||||
inline operator const float* () const{
|
||||
return (const float*)&elt[0][0];
|
||||
}
|
||||
|
||||
/** @deprecated */
|
||||
Vector3 getColumn (int iCol) const;
|
||||
/** @deprecated */
|
||||
Vector3 getRow (int iRow) const;
|
||||
|
||||
Vector3 column(int c) const;
|
||||
const Vector3& row(int r) const;
|
||||
|
||||
void setColumn(int iCol, const Vector3 &vector);
|
||||
void setRow(int iRow, const Vector3 &vector);
|
||||
|
||||
// assignment and comparison
|
||||
inline Matrix3& operator= (const Matrix3& rkMatrix) {
|
||||
memcpy(elt, rkMatrix.elt, 9 * sizeof(float));
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator== (const Matrix3& rkMatrix) const;
|
||||
bool operator!= (const Matrix3& rkMatrix) const;
|
||||
|
||||
// arithmetic operations
|
||||
Matrix3 operator+ (const Matrix3& rkMatrix) const;
|
||||
Matrix3 operator- (const Matrix3& rkMatrix) const;
|
||||
/** Matrix-matrix multiply */
|
||||
Matrix3 operator* (const Matrix3& rkMatrix) const;
|
||||
Matrix3 operator- () const;
|
||||
|
||||
Matrix3& operator+= (const Matrix3& rkMatrix);
|
||||
Matrix3& operator-= (const Matrix3& rkMatrix);
|
||||
Matrix3& operator*= (const Matrix3& rkMatrix);
|
||||
|
||||
/**
|
||||
* matrix * vector [3x3 * 3x1 = 3x1]
|
||||
*/
|
||||
inline Vector3 operator* (const Vector3& v) const {
|
||||
Vector3 kProd;
|
||||
|
||||
for (int r = 0; r < 3; ++r) {
|
||||
kProd[r] =
|
||||
elt[r][0] * v[0] +
|
||||
elt[r][1] * v[1] +
|
||||
elt[r][2] * v[2];
|
||||
}
|
||||
|
||||
return kProd;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* vector * matrix [1x3 * 3x3 = 1x3]
|
||||
*/
|
||||
friend Vector3 operator* (const Vector3& rkVector,
|
||||
const Matrix3& rkMatrix);
|
||||
|
||||
/**
|
||||
* matrix * scalar
|
||||
*/
|
||||
Matrix3 operator* (float fScalar) const;
|
||||
|
||||
/** scalar * matrix */
|
||||
friend Matrix3 operator* (double fScalar, const Matrix3& rkMatrix);
|
||||
friend Matrix3 operator* (float fScalar, const Matrix3& rkMatrix);
|
||||
friend Matrix3 operator* (int fScalar, const Matrix3& rkMatrix);
|
||||
|
||||
private:
|
||||
/** Multiplication where out != A and out != B */
|
||||
static void _mul(const Matrix3& A, const Matrix3& B, Matrix3& out);
|
||||
public:
|
||||
|
||||
/** Optimized implementation of out = A * B. It is safe (but slow) to call
|
||||
with A, B, and out possibly pointer equal to one another.*/
|
||||
// This is a static method so that it is not ambiguous whether "this"
|
||||
// is an input or output argument.
|
||||
inline static void mul(const Matrix3& A, const Matrix3& B, Matrix3& out) {
|
||||
if ((&out == &A) || (&out == &B)) {
|
||||
// We need a temporary anyway, so revert to the stack method.
|
||||
out = A * B;
|
||||
} else {
|
||||
// Optimized in-place multiplication.
|
||||
_mul(A, B, out);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
static void _transpose(const Matrix3& A, Matrix3& out);
|
||||
public:
|
||||
|
||||
/** Optimized implementation of out = A.transpose(). It is safe (but slow) to call
|
||||
with A and out possibly pointer equal to one another.
|
||||
|
||||
Note that <CODE>A.transpose() * v</CODE> can be computed
|
||||
more efficiently as <CODE>v * A</CODE>.
|
||||
*/
|
||||
inline static void transpose(const Matrix3& A, Matrix3& out) {
|
||||
if (&A == &out) {
|
||||
out = A.transpose();
|
||||
} else {
|
||||
_transpose(A, out);
|
||||
}
|
||||
}
|
||||
|
||||
/** Returns true if the rows and column L2 norms are 1.0 and the rows are orthogonal. */
|
||||
bool isOrthonormal() const;
|
||||
|
||||
Matrix3 transpose () const;
|
||||
bool inverse (Matrix3& rkInverse, float fTolerance = 1e-06) const;
|
||||
Matrix3 inverse (float fTolerance = 1e-06) const;
|
||||
float determinant () const;
|
||||
|
||||
/** singular value decomposition */
|
||||
void singularValueDecomposition (Matrix3& rkL, Vector3& rkS,
|
||||
Matrix3& rkR) const;
|
||||
/** singular value decomposition */
|
||||
void singularValueComposition (const Matrix3& rkL,
|
||||
const Vector3& rkS, const Matrix3& rkR);
|
||||
|
||||
/** Gram-Schmidt orthonormalization (applied to columns of rotation matrix) */
|
||||
void orthonormalize();
|
||||
|
||||
/** orthogonal Q, diagonal D, upper triangular U stored as (u01,u02,u12) */
|
||||
void qDUDecomposition (Matrix3& rkQ, Vector3& rkD,
|
||||
Vector3& rkU) const;
|
||||
|
||||
float spectralNorm () 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);
|
||||
|
||||
/**
|
||||
* The matrix must be orthonormal. The decomposition is yaw*pitch*roll
|
||||
* where yaw is rotation about the Up vector, pitch is rotation about the
|
||||
* right axis, and roll is rotation about the Direction axis.
|
||||
*/
|
||||
bool toEulerAnglesXYZ (float& rfYAngle, float& rfPAngle,
|
||||
float& rfRAngle) const;
|
||||
bool toEulerAnglesXZY (float& rfYAngle, float& rfPAngle,
|
||||
float& rfRAngle) const;
|
||||
bool toEulerAnglesYXZ (float& rfYAngle, float& rfPAngle,
|
||||
float& rfRAngle) const;
|
||||
bool toEulerAnglesYZX (float& rfYAngle, float& rfPAngle,
|
||||
float& rfRAngle) const;
|
||||
bool toEulerAnglesZXY (float& rfYAngle, float& rfPAngle,
|
||||
float& rfRAngle) const;
|
||||
bool toEulerAnglesZYX (float& rfYAngle, float& rfPAngle,
|
||||
float& rfRAngle) const;
|
||||
static Matrix3 fromEulerAnglesXYZ (float fYAngle, float fPAngle, float fRAngle);
|
||||
static Matrix3 fromEulerAnglesXZY (float fYAngle, float fPAngle, float fRAngle);
|
||||
static Matrix3 fromEulerAnglesYXZ (float fYAngle, float fPAngle, float fRAngle);
|
||||
static Matrix3 fromEulerAnglesYZX (float fYAngle, float fPAngle, float fRAngle);
|
||||
static Matrix3 fromEulerAnglesZXY (float fYAngle, float fPAngle, float fRAngle);
|
||||
static Matrix3 fromEulerAnglesZYX (float fYAngle, float fPAngle, float fRAngle);
|
||||
|
||||
/** eigensolver, matrix must be symmetric */
|
||||
void eigenSolveSymmetric (float afEigenvalue[3],
|
||||
Vector3 akEigenvector[3]) const;
|
||||
|
||||
static void tensorProduct (const Vector3& rkU, const Vector3& rkV,
|
||||
Matrix3& rkProduct);
|
||||
std::string toString() const;
|
||||
|
||||
static const float EPSILON;
|
||||
|
||||
// Special values.
|
||||
// The unguaranteed order of initialization of static variables across
|
||||
// translation units can be a source of annoying bugs, so now the static
|
||||
// special values (like Vector3::ZERO, Color3::WHITE, ...) are wrapped
|
||||
// inside static functions that return references to them.
|
||||
// These functions are intentionally not inlined, because:
|
||||
// "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
|
||||
// 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
|
||||
// units, which would certainly cause problems. So you must
|
||||
// ensure that there is only one definition of each wrapping
|
||||
// function, and this means not making the wrapping functions inline",
|
||||
// according to Chapter 10 of "Thinking in C++, 2nd ed. Volume 1" by Bruce Eckel,
|
||||
// http://www.mindview.net/
|
||||
static const Matrix3& zero();
|
||||
static const Matrix3& identity();
|
||||
|
||||
protected:
|
||||
|
||||
// support for eigensolver
|
||||
void tridiagonal (float afDiag[3], float afSubDiag[3]);
|
||||
bool qLAlgorithm (float afDiag[3], float afSubDiag[3]);
|
||||
|
||||
// support for singular value decomposition
|
||||
static const float ms_fSvdEpsilon;
|
||||
static const int ms_iSvdMaxIterations;
|
||||
static void bidiagonalize (Matrix3& kA, Matrix3& kL,
|
||||
Matrix3& kR);
|
||||
static void golubKahanStep (Matrix3& kA, Matrix3& kL,
|
||||
Matrix3& kR);
|
||||
|
||||
// support for spectral norm
|
||||
static float maxCubicRoot (float afCoeff[3]);
|
||||
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
/** <code>v * M == M.transpose() * v</code> */
|
||||
inline Vector3 operator* (const Vector3& rkPoint, const Matrix3& rkMatrix) {
|
||||
Vector3 kProd;
|
||||
|
||||
for (int r = 0; r < 3; ++r) {
|
||||
kProd[r] =
|
||||
rkPoint[0] * rkMatrix.elt[0][r] +
|
||||
rkPoint[1] * rkMatrix.elt[1][r] +
|
||||
rkPoint[2] * rkMatrix.elt[2][r];
|
||||
}
|
||||
|
||||
return kProd;
|
||||
}
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
|
||||
+206
@@ -0,0 +1,206 @@
|
||||
/**
|
||||
@file Matrix4.h
|
||||
|
||||
4x4 matrix class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-10-02
|
||||
@edited 2007-04-05
|
||||
*/
|
||||
|
||||
#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 {
|
||||
|
||||
/**
|
||||
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:
|
||||
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 <B>row major</B>.
|
||||
*/
|
||||
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();
|
||||
|
||||
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 <b>NEGATIVE</b> of the near and far plane Z values
|
||||
(to follow OpenGL conventions).
|
||||
*/
|
||||
static Matrix4 orthogonalProjection(
|
||||
float left,
|
||||
float right,
|
||||
float bottom,
|
||||
float top,
|
||||
float nearval,
|
||||
float farval);
|
||||
|
||||
static Matrix4 orthogonalProjection(
|
||||
const class Rect2D& rect,
|
||||
float nearval,
|
||||
float farval);
|
||||
|
||||
static Matrix4 perspectiveProjection(
|
||||
float left,
|
||||
float right,
|
||||
float bottom,
|
||||
float top,
|
||||
float nearval,
|
||||
float farval);
|
||||
|
||||
void setRow(int r, const class Vector4& v);
|
||||
void setColumn(int c, const Vector4& v);
|
||||
|
||||
/** @deprecated */
|
||||
Vector4 getRow(int r) const;
|
||||
/** @deprecated */
|
||||
Vector4 getColumn(int c) const;
|
||||
|
||||
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);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
+718
@@ -0,0 +1,718 @@
|
||||
/**
|
||||
@file MeshAlg.h
|
||||
|
||||
Indexed Mesh algorithms.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-09-14
|
||||
@edited 2008-07-30
|
||||
*/
|
||||
|
||||
#ifndef G3D_MESHALG_H
|
||||
#define G3D_MESHALG_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/CoordinateFrame.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Indexed <B>mesh alg</B>orithms. You have to build your own mesh class.
|
||||
<P>
|
||||
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.
|
||||
*/
|
||||
class MeshAlg {
|
||||
public:
|
||||
|
||||
enum Primitive {LINES, LINE_STRIP, TRIANGLES, TRIANGLE_STRIP,
|
||||
TRIANGLE_FAN, QUADS, QUAD_STRIP, POINTS};
|
||||
|
||||
|
||||
/** Adjacency information for a vertex.
|
||||
Does not contain the vertex position or normal,
|
||||
which are stored in the MeshAlg::Geometry object.
|
||||
<CODE>Vertex</CODE>s 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.
|
||||
*/
|
||||
Array<int> 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.
|
||||
*/
|
||||
Array<int> 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 <CODE>edgeIndex[i] >= 0</CODE> then this face
|
||||
contains the directed edge
|
||||
between vertex indices
|
||||
<CODE>edgeArray[face.edgeIndex[i]].vertexIndex[0]</CODE>
|
||||
and
|
||||
<CODE>edgeArray[face.edgeIndex[i]].vertexIndex[1]</CODE>.
|
||||
|
||||
If <CODE>edgeIndex[i] < 0</CODE> then
|
||||
<CODE>~edgeIndex[i]</CODE> (i.e. the two's
|
||||
complement of) is used and this face contains the directed
|
||||
edge between vertex indices
|
||||
<CODE>edgeArray[~face.edgeIndex[i]].vertexIndex[0]</CODE>
|
||||
and
|
||||
<CODE>edgeArray[~face.edgeIndex[i]].vertexIndex[1]</CODE>.
|
||||
|
||||
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 <B>forward</B> in face 0
|
||||
<B>backward</B> 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<Vector3> vertexArray;
|
||||
|
||||
/** Vertex normals */
|
||||
Array<Vector3> 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.
|
||||
|
||||
<B>Colocated vertices are treated as separate.</B> To have
|
||||
colocated vertices collapsed (necessary for many algorithms,
|
||||
like shadowing), weld the mesh before computing adjacency.
|
||||
|
||||
<I>Recent change: In version 6.00, colocated vertices were automatically
|
||||
welded by this routine and degenerate faces and edges were removed. That
|
||||
is no longer the case.</I>
|
||||
|
||||
Where two faces meet, there are two opposite directed edges. These
|
||||
are collapsed into a single bidirectional edge in the edgeArray.
|
||||
If four faces meet exactly at the same edge, that edge will appear
|
||||
twice in the array, and so on. If an edge is a boundary of the mesh
|
||||
(i.e. if the edge has only one adjacent face) it will appear in the
|
||||
array with one face index set to MeshAlg::Face::NONE.
|
||||
|
||||
@param vertexGeometry %Vertex positions to use when deciding colocation.
|
||||
@param indexArray Order to traverse vertices to make triangles
|
||||
@param faceArray <I>Output</I>
|
||||
@param edgeArray <I>Output</I>. Sorted so that boundary edges are at the end of the array.
|
||||
@param vertexArray <I>Output</I>
|
||||
*/
|
||||
static void computeAdjacency(
|
||||
const Array<Vector3>& vertexGeometry,
|
||||
const Array<int>& indexArray,
|
||||
Array<Face>& faceArray,
|
||||
Array<Edge>& edgeArray,
|
||||
Array<Vertex>& vertexArray);
|
||||
|
||||
/**
|
||||
@deprecated Use the other version of computeAdjacency, which takes Array<Vertex>.
|
||||
@param facesAdjacentToVertex <I>Output</I> adjacentFaceArray[v] is an array of
|
||||
indices for faces touching vertex index v
|
||||
*/
|
||||
static void computeAdjacency(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<int>& indexArray,
|
||||
Array<Face>& faceArray,
|
||||
Array<Edge>& edgeArray,
|
||||
Array< Array<int> >& facesAdjacentToVertex);
|
||||
|
||||
/**
|
||||
Computes some basic mesh statistics including: min, max mean and median,
|
||||
edge lengths; and min, mean, median, and max face area.
|
||||
|
||||
@param vertexGeometry %Vertex positions to use when deciding colocation.
|
||||
@param indexArray Order to traverse vertices to make triangles
|
||||
@param minEdgeLength Minimum edge length
|
||||
@param meanEdgeLength Mean edge length
|
||||
@param medianEdgeLength Median edge length
|
||||
@param maxEdgeLength Max edge length
|
||||
@param minFaceArea Minimum face area
|
||||
@param meanFaceArea Mean face area
|
||||
@param medianFaceArea Median face area
|
||||
@param maxFaceArea Max face area
|
||||
*/
|
||||
static void computeAreaStatistics(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<int>& indexArray,
|
||||
double& minEdgeLength,
|
||||
double& meanEdgeLength,
|
||||
double& medianEdgeLength,
|
||||
double& maxEdgeLength,
|
||||
double& minFaceArea,
|
||||
double& meanFaceArea,
|
||||
double& medianFaceArea,
|
||||
double& maxFaceArea);
|
||||
|
||||
private:
|
||||
/**
|
||||
Computes the tangent space basis vectors for
|
||||
a counter-clockwise oriented face.
|
||||
|
||||
@cite Max McGuire
|
||||
*/
|
||||
static void computeTangentVectors(
|
||||
const Vector3& normal,
|
||||
const Vector3 position[3],
|
||||
const Vector2 texCoord[3],
|
||||
Vector3& tangent,
|
||||
Vector3& binormal);
|
||||
|
||||
/** Helper for weldAdjacency */
|
||||
static void weldBoundaryEdges(
|
||||
Array<Face>& faceArray,
|
||||
Array<Edge>& edgeArray,
|
||||
Array<Vertex>& vertexArray);
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
Computes tangent and binormal vectors,
|
||||
which provide a (mostly) consistent
|
||||
parameterization over the surface for
|
||||
effects like bump mapping. In the resulting coordinate frame,
|
||||
T = x (varies with texture s coordinate), B = y (varies with negative texture t coordinate),
|
||||
and N = z for a right-handed coordinate frame. If a billboard is vertical on the screen
|
||||
in view of the camera, the tangent space matches the camera's coordinate frame.
|
||||
|
||||
The vertex, texCoord, tangent, and binormal
|
||||
arrays are parallel arrays.
|
||||
|
||||
The resulting tangent and binormal might not be exactly
|
||||
perpendicular to each other. They are guaranteed to
|
||||
be perpendicular to the normal.
|
||||
|
||||
@cite Max McGuire
|
||||
*/
|
||||
static void computeTangentSpaceBasis(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<Vector2>& texCoordArray,
|
||||
const Array<Vector3>& vertexNormalArray,
|
||||
const Array<Face>& faceArray,
|
||||
Array<Vector3>& tangent,
|
||||
Array<Vector3>& binormal);
|
||||
|
||||
/** @deprecated */
|
||||
static void computeNormals(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<Face>& faceArray,
|
||||
const Array< Array<int> >& adjacentFaceArray,
|
||||
Array<Vector3>& vertexNormalArray,
|
||||
Array<Vector3>& faceNormalArray);
|
||||
|
||||
/**
|
||||
Vertex normals are weighted by the area of adjacent faces.
|
||||
Nelson Max showed this is superior to uniform weighting for
|
||||
general meshes in jgt.
|
||||
|
||||
@param vertexNormalArray Output. Unit length
|
||||
@param faceNormalArray Output. Degenerate faces produce zero magnitude normals. Unit length
|
||||
@see weld
|
||||
*/
|
||||
static void computeNormals(
|
||||
const Array<Vector3>& vertexGeometry,
|
||||
const Array<Face>& faceArray,
|
||||
const Array<Vertex>& vertexArray,
|
||||
Array<Vector3>& vertexNormalArray,
|
||||
Array<Vector3>& faceNormalArray);
|
||||
|
||||
/** Computes unit length normals in place using the other computeNormals methods.
|
||||
If you already have a face array use another method; it will be faster.
|
||||
@see weld*/
|
||||
static void computeNormals(
|
||||
Geometry& geometry,
|
||||
const Array<int>& indexArray);
|
||||
|
||||
/**
|
||||
Computes face normals only. Significantly faster (especially if
|
||||
normalize is false) than computeNormals.
|
||||
@see weld
|
||||
*/
|
||||
static void computeFaceNormals(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<Face>& faceArray,
|
||||
Array<Vector3>& faceNormals,
|
||||
bool normalize = true);
|
||||
|
||||
/**
|
||||
Classifies each face as a backface or a front face relative
|
||||
to the observer point P (which is at infinity when P.w = 0).
|
||||
A face with normal exactly perpendicular to the observer vector
|
||||
may be classified as either a front or a back face arbitrarily.
|
||||
*/
|
||||
static void identifyBackfaces(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<Face>& faceArray,
|
||||
const Vector4& P,
|
||||
Array<bool>& backface);
|
||||
|
||||
/** A faster version of identifyBackfaces for the case where
|
||||
face normals have already been computed */
|
||||
static void identifyBackfaces(
|
||||
const Array<Vector3>& vertexArray,
|
||||
const Array<Face>& faceArray,
|
||||
const Vector4& P,
|
||||
Array<bool>& backface,
|
||||
const Array<Vector3>& faceNormals);
|
||||
|
||||
/**
|
||||
Welds nearby and colocated elements of the <I>oldVertexArray</I> together so that
|
||||
<I>newVertexArray</I> contains no vertices within <I>radius</I> of one another.
|
||||
Every vertex in newVertexPositions also appears in oldVertexPositions.
|
||||
This is useful for downsampling meshes and welding cracks created by artist errors
|
||||
or numerical imprecision.
|
||||
|
||||
The two integer arrays map indices back and forth between the arrays according to:
|
||||
<PRE>
|
||||
oldVertexArray[toOld[ni]] == newVertexArray[ni]
|
||||
oldVertexArray[oi] == newVertexArray[toNew[ni]]
|
||||
</PRE>
|
||||
|
||||
Note that newVertexPositions is never longer than oldVertexPositions
|
||||
and is shorter when vertices are welded.
|
||||
|
||||
Welding with a large radius will effectively compute a lower level of detail for
|
||||
the mesh.
|
||||
|
||||
The welding method runs in roughly linear time in the length of oldVertexArray--
|
||||
a uniform spatial grid is used to achieve nearly constant time vertex collapses
|
||||
for uniformly distributed vertices.
|
||||
|
||||
It is sometimes desirable to keep the original vertex ordering but
|
||||
identify the unique vertices. The following code computes
|
||||
array canonical s.t. canonical[v] = first occurance of
|
||||
a vertex near oldVertexPositions[v] in oldVertexPositions.
|
||||
|
||||
<PRE>
|
||||
Array<int> canonical(oldVertexPositions.size()), toNew, toOld;
|
||||
computeWeld(oldVertexPositions, Array<Vector3>(), toNew, toOld, radius);
|
||||
for (int v = 0; v < canonical.size(); ++v) {
|
||||
canonical[v] = toOld[toNew[v]];
|
||||
}
|
||||
</PRE>
|
||||
|
||||
See also G3D::MeshAlg::weldAdjacency.
|
||||
|
||||
@cite The method is that described as the 'Grouper' in Baum, Mann, Smith, and Winget,
|
||||
Making Radiosity Usable: Automatic Preprocessing and Meshing Techniques for
|
||||
the Generation of Accurate Radiosity Solutions, Computer Graphics vol 25, no 4, July 1991.
|
||||
|
||||
@deprecated Use weld.
|
||||
*/
|
||||
static void computeWeld(
|
||||
const Array<Vector3>& oldVertexPositions,
|
||||
Array<Vector3>& newVertexPositions,
|
||||
Array<int>& toNew,
|
||||
Array<int>& toOld,
|
||||
double radius = G3D::fuzzyEpsilon);
|
||||
|
||||
/**
|
||||
Modifies the face, edge, and vertex arrays in place so that
|
||||
colocated (within radius) vertices are treated as identical.
|
||||
Note that the vertexArray and corresponding geometry will
|
||||
contain elements that are no longer used. In the vertexArray,
|
||||
these elements are initialized to MeshAlg::Vertex() but not
|
||||
removed (because removal would change the indexing).
|
||||
|
||||
This is a good preprocessing step for algorithms that are only
|
||||
concerned with the shape of a mesh (e.g. cartoon rendering, fur, shadows)
|
||||
and not the indexing of the vertices.
|
||||
|
||||
Use this method when you have already computed adjacency information
|
||||
and want to collapse colocated vertices within that data without
|
||||
disturbing the actual mesh vertices or indexing scheme.
|
||||
|
||||
If you have not computed adjacency already, use MeshAlg::computeWeld
|
||||
instead and compute adjacency information after welding.
|
||||
|
||||
@deprecated Use weld.
|
||||
|
||||
@param faceArray Mutated in place. Size is maintained (degenerate
|
||||
faces are <b>not</B> removed).
|
||||
@param edgeArray Mutated in place. May shrink if boundary edges
|
||||
are welded together.
|
||||
@param vertexArray Mutated in place. Size is maintained (duplicate
|
||||
vertices contain no adjacency info).
|
||||
*/
|
||||
static void weldAdjacency(
|
||||
const Array<Vector3>& originalGeometry,
|
||||
Array<Face>& faceArray,
|
||||
Array<Edge>& edgeArray,
|
||||
Array<Vertex>& vertexArray,
|
||||
double radius = G3D::fuzzyEpsilon);
|
||||
|
||||
|
||||
/**
|
||||
Counts the number of edges (in an edge array returned from
|
||||
MeshAlg::computeAdjacency) that have only one adjacent face.
|
||||
*/
|
||||
static int countBoundaryEdges(const Array<Edge>& edgeArray);
|
||||
|
||||
|
||||
/**
|
||||
Generates an array of integers from start to start + n - 1 that have run numbers
|
||||
in series then omit the next skip before the next run. Useful for turning
|
||||
a triangle list into an indexed face set.
|
||||
|
||||
Example:
|
||||
<PRE>
|
||||
createIndexArray(10, x);
|
||||
// x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
|
||||
|
||||
createIndexArray(5, x, 2);
|
||||
// x = [2, 3, 4, 5, 6, 7]
|
||||
|
||||
createIndexArray(6, x, 0, 2, 1);
|
||||
// x = [0, 1, 3, 4, 6, 7]
|
||||
</PRE>
|
||||
*/
|
||||
static void createIndexArray(
|
||||
int n,
|
||||
Array<int>& array,
|
||||
int start = 0,
|
||||
int run = 1,
|
||||
int skip = 0);
|
||||
|
||||
/**
|
||||
Computes a conservative, near-optimal axis aligned bounding box and sphere.
|
||||
|
||||
@cite The bounding sphere uses the method from J. Ritter. An effcient bounding sphere. In Andrew S. Glassner, editor, Graphics Gems. Academic Press, Boston, MA, 1990.
|
||||
|
||||
*/
|
||||
static void computeBounds(const Array<Vector3>& vertex, class Box& box, class Sphere& sphere);
|
||||
|
||||
/** Computes bounds for a subset of the vertices. It is ok if vertices appear more than once in the index array. */
|
||||
static void computeBounds(const Array<Vector3>& vertex, const Array<int>& index, class Box& box, class Sphere& sphere);
|
||||
|
||||
/**
|
||||
Mutates geometry, texCoord, and indexArray so that the output has collocated vertices collapsed (welded).
|
||||
|
||||
@param vertices Input and output
|
||||
@param textureCoords Input and output
|
||||
@param normals Output only
|
||||
@param indices Input and output. This is an array of trilist indices.
|
||||
@param oldToNewIndex Output argument
|
||||
@param normalSmoothingAngle Varies from 0 (flat shading) to toRadians(180) for extremely smooth shading. Default is toRadians(70)
|
||||
*/
|
||||
static void weld(
|
||||
Array<Vector3>& vertices,
|
||||
Array<Vector2>& textureCoords,
|
||||
Array<Vector3>& normals,
|
||||
Array<Array<int>*>& indices,
|
||||
float normalSmoothingAngle = toRadians(70.0f),
|
||||
float vertexWeldRadius = 0.0001f,
|
||||
float textureWeldRadius = 0.0001f,
|
||||
float normalWeldRadius = 0.01f);
|
||||
|
||||
inline static void weld(
|
||||
Array<Vector3>& vertices,
|
||||
Array<Vector2>& textureCoords,
|
||||
Array<Vector3>& normals,
|
||||
Array<int>& indices,
|
||||
float normalSmoothingAngle = toRadians(70.0f),
|
||||
float vertexWeldRadius = 0.0002f,
|
||||
float textureWeldRadius = 0.00001f,
|
||||
float normalWeldRadius = 0.00001f) {
|
||||
|
||||
Array<Array<int>*> meta;
|
||||
meta.append(&indices);
|
||||
weld(vertices, textureCoords, normals, meta, normalSmoothingAngle, vertexWeldRadius, textureWeldRadius, normalWeldRadius);
|
||||
}
|
||||
|
||||
/**
|
||||
In debug mode, asserts that the adjacency references between the
|
||||
face, edge, and vertex array are consistent.
|
||||
*/
|
||||
static void debugCheckConsistency(
|
||||
const Array<Face>& faceArray,
|
||||
const Array<Edge>& edgeArray,
|
||||
const Array<Vertex>& vertexArray);
|
||||
|
||||
/**
|
||||
Generates a unit square in the X-Z plane composed of a grid of wCells x hCells
|
||||
squares and then transforms it by xform.
|
||||
|
||||
@param vertex Output vertices
|
||||
@param texCoord Output texture coordinates
|
||||
@param index Output triangle list indices
|
||||
@param textureScale Lower-right texture coordinate
|
||||
@param spaceCentered If true, the coordinates generated are centered at the origin before the transformation.
|
||||
@param twoSided If true, matching top and bottom planes are generated.
|
||||
*/
|
||||
static void generateGrid(
|
||||
Array<Vector3>& vertex,
|
||||
Array<Vector2>& texCoord,
|
||||
Array<int>& index,
|
||||
int wCells = 10,
|
||||
int hCells = 10,
|
||||
const Vector2& textureScale = Vector2(1,1),
|
||||
bool spaceCentered = true,
|
||||
bool twoSided = true,
|
||||
const CoordinateFrame& xform = CoordinateFrame());
|
||||
|
||||
/** Converts quadlist (QUADS),
|
||||
triangle fan (TRIANGLE_FAN),
|
||||
tristrip(TRIANGLE_STRIP), and quadstrip (QUAD_STRIP) indices into
|
||||
triangle list (TRIANGLES) indices and appends them to outIndices. */
|
||||
template<class IndexType>
|
||||
static void toIndexedTriList(
|
||||
const Array<IndexType>& inIndices,
|
||||
MeshAlg::Primitive inType,
|
||||
Array<IndexType>& outIndices) {
|
||||
|
||||
debugAssert(
|
||||
inType == MeshAlg::TRIANGLE_STRIP ||
|
||||
inType == MeshAlg::TRIANGLE_FAN ||
|
||||
inType == MeshAlg::QUADS ||
|
||||
inType == MeshAlg::QUAD_STRIP);
|
||||
|
||||
const int inSize = inIndices.size();
|
||||
|
||||
switch(inType) {
|
||||
case MeshAlg::TRIANGLE_FAN:
|
||||
{
|
||||
debugAssert(inSize >= 3);
|
||||
|
||||
int N = outIndices.size();
|
||||
outIndices.resize(N + (inSize - 2) * 3);
|
||||
|
||||
for (IndexType i = 1, outIndex = N; i <= (inSize - 2); ++i, outIndex += 3) {
|
||||
outIndices[outIndex] = inIndices[0];
|
||||
outIndices[outIndex + 1] = inIndices[i];
|
||||
outIndices[outIndex + 2] = inIndices[i + 1];
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case MeshAlg::TRIANGLE_STRIP:
|
||||
{
|
||||
debugAssert(inSize >= 3);
|
||||
|
||||
int N = outIndices.size();
|
||||
outIndices.resize(N + (inSize - 2) * 3);
|
||||
|
||||
bool atEven = false;
|
||||
for (IndexType i = 0, outIndex = N; i <= (inSize - 2); ++i, outIndex += 3) {
|
||||
if (atEven) {
|
||||
outIndices[outIndex] = inIndices[i + 1];
|
||||
outIndices[outIndex + 1] = inIndices[i];
|
||||
outIndices[outIndex + 2] = inIndices[i + 2];
|
||||
atEven = false;
|
||||
} else {
|
||||
outIndices[outIndex] = inIndices[i];
|
||||
outIndices[outIndex + 1] = inIndices[i + 1];
|
||||
outIndices[outIndex + 2] = inIndices[i + 2];
|
||||
atEven = true;
|
||||
}
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case MeshAlg::QUADS:
|
||||
{
|
||||
debugAssert(inIndices.size() >= 4);
|
||||
|
||||
int N = outIndices.size();
|
||||
outIndices.resize(N + (inSize / 4) * 3);
|
||||
|
||||
for (IndexType i = 0, outIndex = N; i <= (inSize - 4); i += 4, outIndex += 6) {
|
||||
outIndices[outIndex] = inIndices[i];
|
||||
outIndices[outIndex + 1] = inIndices[i + 1];
|
||||
outIndices[outIndex + 2] = inIndices[i + 3];
|
||||
outIndices[outIndex + 3] = inIndices[i + 1];
|
||||
outIndices[outIndex + 4] = inIndices[i + 2];
|
||||
outIndices[outIndex + 5] = inIndices[i + 3];
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case MeshAlg::QUAD_STRIP:
|
||||
{
|
||||
debugAssert(inIndices.size() >= 4);
|
||||
|
||||
int N = outIndices.size();
|
||||
outIndices.resize(N + (inSize - 2) * 3);
|
||||
|
||||
for (IndexType i = 0, outIndex = N; i <= (inSize - 2); i += 2, outIndex += 6) {
|
||||
outIndices[outIndex] = inIndices[i];
|
||||
outIndices[outIndex + 1] = inIndices[i + 1];
|
||||
outIndices[outIndex + 2] = inIndices[i + 2];
|
||||
outIndices[outIndex + 3] = inIndices[i + 2];
|
||||
outIndices[outIndex + 4] = inIndices[i + 1];
|
||||
outIndices[outIndex + 5] = inIndices[i + 3];
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
alwaysAssertM(false, "Illegal argument");
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
/**
|
||||
Helper for computeAdjacency. If a directed edge with index e already
|
||||
exists from i0 to i1 then e is returned. If a directed edge with index e
|
||||
already exists from i1 to i0, ~e is returned (the complement) and
|
||||
edgeArray[e] is set to f. Otherwise, a new edge is created from i0 to i1
|
||||
with first face index f and its index is returned.
|
||||
|
||||
@param vertexArray Vertex positions to use when deciding colocation.
|
||||
|
||||
@param area Area of face f. When multiple edges of the same direction
|
||||
are found between the same vertices (usually because of degenerate edges)
|
||||
the face with larger area is kept in the edge table.
|
||||
*/
|
||||
static int findEdgeIndex(
|
||||
const Array<Vector3>& vertexArray,
|
||||
Array<Edge>& geometricEdgeArray,
|
||||
int i0, int i1, int f, double area);
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
@file MeshBuilder.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2002-02-27
|
||||
@edited 2004-10-04
|
||||
*/
|
||||
#ifndef G3D_MESHBUILDER_H
|
||||
#define G3D_MESHBUILDER_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Triangle.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Allows creation of optimized watertight meshes from unoptimized polygon soups.
|
||||
See also G3D::MeshAlg for algorithms that operate on the output.
|
||||
*/
|
||||
class MeshBuilder {
|
||||
public:
|
||||
|
||||
/**
|
||||
Set setWeldRadius to AUTO_WELD to weld vertices closer than 1/2
|
||||
the smallest edge length in a model.
|
||||
*/
|
||||
enum {AUTO_WELD = -100};
|
||||
|
||||
private:
|
||||
/** Indices of vertices in <B>or near</B> a grid cell. */
|
||||
typedef Array<int> List;
|
||||
|
||||
std::string name;
|
||||
|
||||
/**
|
||||
All of the triangles, as a long triangle list.
|
||||
*/
|
||||
Array<Vector3> triList;
|
||||
|
||||
void centerTriList();
|
||||
void computeBounds(Vector3& min, Vector3& max);
|
||||
|
||||
bool _twoSided;
|
||||
|
||||
/** Collapse radius */
|
||||
double close;
|
||||
|
||||
public:
|
||||
|
||||
inline MeshBuilder(bool twoSided = false) : _twoSided(twoSided), close(AUTO_WELD) {}
|
||||
|
||||
/** Writes the model to the arrays, which can then be used with
|
||||
G3D::IFSModel::save and G3D::MeshAlg */
|
||||
void commit(std::string& name, Array<int>& indexArray, Array<Vector3>& vertexArray);
|
||||
|
||||
/**
|
||||
Adds a new triangle to the model. (Counter clockwise)
|
||||
*/
|
||||
void addTriangle(const Vector3& a, const Vector3& b, const Vector3& c);
|
||||
|
||||
/**
|
||||
Adds two new triangles to the model. (Counter clockwise)
|
||||
*/
|
||||
void addQuad(const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d);
|
||||
|
||||
void addTriangle(const Triangle& t);
|
||||
|
||||
void setName(const std::string& n);
|
||||
|
||||
/** Vertices within this distance are considered identical.
|
||||
Use AUTO_WELD (the default) to have the distance be a function of the model size.*/
|
||||
void setWeldRadius(double r) {
|
||||
close = r;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
+132
@@ -0,0 +1,132 @@
|
||||
#ifndef G3D_NETADDRESS_H
|
||||
#define G3D_NETADDRESS_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Table.h"
|
||||
|
||||
/** These control the version of Winsock used by G3D.
|
||||
Version 2.0 is standard for G3D 6.09 and later.
|
||||
Version 1.1 is standard for G3D 6.08 and earlier.
|
||||
*/
|
||||
#define G3D_WINSOCK_MAJOR_VERSION 2
|
||||
#define G3D_WINSOCK_MINOR_VERSION 0
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
# if (G3D_WINSOCK_MAJOR_VERSION == 2)
|
||||
# include <winsock2.h>
|
||||
# elif (G3D_WINSOCK_MAJOR_VERSION == 1)
|
||||
# include <winsock.h>
|
||||
# endif
|
||||
#else
|
||||
# include <sys/types.h>
|
||||
# include <sys/socket.h>
|
||||
# include <netinet/in.h>
|
||||
# ifndef SOCKADDR_IN
|
||||
# define SOCKADDR_IN struct sockaddr_in
|
||||
# endif
|
||||
# ifndef SOCKET
|
||||
# define SOCKET int
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class NetAddress {
|
||||
private:
|
||||
friend class NetworkDevice;
|
||||
friend class LightweightConduit;
|
||||
friend class ReliableConduit;
|
||||
|
||||
/** Host byte order */
|
||||
void init(uint32 host, uint16 port);
|
||||
void init(const std::string& hostname, uint16 port);
|
||||
NetAddress(const SOCKADDR_IN& a);
|
||||
NetAddress(const struct in_addr& addr, uint16 port = 0);
|
||||
|
||||
SOCKADDR_IN addr;
|
||||
|
||||
public:
|
||||
/**
|
||||
In host byte order
|
||||
*/
|
||||
NetAddress(uint32 host, uint16 port = 0);
|
||||
|
||||
/**
|
||||
@param port Specified in host byte order (i.e., don't worry about endian issues)
|
||||
*/
|
||||
NetAddress(const std::string& hostname, uint16 port);
|
||||
|
||||
/**
|
||||
@param hostnameAndPort in the form "hostname:port" or "ip:port"
|
||||
*/
|
||||
NetAddress(const std::string& hostnameAndPort);
|
||||
|
||||
/**
|
||||
@deprecated Use G3D::NetworkDevice::broadcastAddressArray()
|
||||
|
||||
@brief Creates a UDP broadcast address for use with a
|
||||
G3D::LightweightConduit.
|
||||
|
||||
UDP broadcast allows one machine to send a packet to all machines
|
||||
on the same local network. The IP portion of the address is
|
||||
0xFFFFFFFF, which indicates "broadcast" to the underlying socket
|
||||
API. This feature is not available with the connection-based TCP
|
||||
protocol abstracted by G3D::ReliableConduit; use multisend
|
||||
instead.
|
||||
*/
|
||||
static NetAddress broadcastAddress(uint16 port);
|
||||
|
||||
NetAddress();
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
/** @brief Returns true if this is not an illegal address. */
|
||||
bool ok() const;
|
||||
|
||||
/** @brief Returns a value in host format (i.e., don't worry about
|
||||
endian issues) */
|
||||
inline uint32 ip() const {
|
||||
return ntohl(addr.sin_addr.s_addr);
|
||||
//return ntohl(addr.sin_addr.S_un.S_addr);
|
||||
}
|
||||
|
||||
inline uint16 port() const {
|
||||
return ntohs(addr.sin_port);
|
||||
}
|
||||
|
||||
std::string ipString() const;
|
||||
std::string toString() const;
|
||||
|
||||
};
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const NetAddress&);
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
template <> struct HashTrait<G3D::NetAddress> {
|
||||
static size_t hashCode(const G3D::NetAddress& key) {
|
||||
return static_cast<size_t>(key.ip() + (static_cast<G3D::uint32>(key.port()) << 16));
|
||||
}
|
||||
};
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Two addresses may point to the same computer but be != because
|
||||
they have different IP's.
|
||||
*/
|
||||
inline bool operator==(const NetAddress& a, const NetAddress& b) {
|
||||
return (a.ip() == b.ip()) && (a.port() == b.port());
|
||||
}
|
||||
|
||||
|
||||
inline bool operator!=(const NetAddress& a, const NetAddress& b) {
|
||||
return !(a == b);
|
||||
}
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,738 @@
|
||||
/**
|
||||
@file NetworkDevice.h
|
||||
|
||||
These classes abstract networking from the socket level to a
|
||||
serialized messaging style that is more appropriate for games. The
|
||||
performance has been tuned for sending many small messages. The
|
||||
message protocol contains a header that prevents them from being used
|
||||
with raw UDP/TCP (e.g. connecting to an HTTP server).
|
||||
|
||||
LightweightConduit and ReliableConduits have different interfaces
|
||||
because they have different semantics. You would never want to
|
||||
interchange them without rewriting the surrounding code.
|
||||
|
||||
NetworkDevice creates conduits because they need access to a global
|
||||
log pointer and because I don't want non-reference counted conduits
|
||||
being created.
|
||||
|
||||
Be careful with threads and reference counting. The reference
|
||||
counters are not threadsafe, and are also not updated correctly if a
|
||||
thread is explicitly killed. Since the conduits will be passed by
|
||||
const XConduitRef& most of the time this doesn't appear as a major
|
||||
problem. With non-blocking conduits, you should need few threads
|
||||
anyway.
|
||||
|
||||
LightweightConduits preceed each message with a 4-byte host order
|
||||
unsigned integer that is the message type. This does not appear in
|
||||
the message serialization/deserialization.
|
||||
|
||||
ReliableConduits preceed each message with two 4-byte host order
|
||||
unsigned integers. The first is the message type and the second
|
||||
indicates the length of the rest of the data. The size does not
|
||||
include the size of the header itself. The minimum message is 9
|
||||
bytes:a 4-byte type, a 4-byte header equal to "1", and one byte of data.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2002-11-22
|
||||
@edited 2006-11-25
|
||||
*/
|
||||
|
||||
#ifndef G3D_NETWORKDEVICE_H
|
||||
#define G3D_NETWORKDEVICE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/NetAddress.h"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
#include "G3D/ReferenceCount.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/BinaryOutput.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class TextOutput;
|
||||
|
||||
class Conduit : public ReferenceCountedObject {
|
||||
protected:
|
||||
friend class NetworkDevice;
|
||||
friend class NetListener;
|
||||
|
||||
uint64 mSent;
|
||||
uint64 mReceived;
|
||||
uint64 bSent;
|
||||
uint64 bReceived;
|
||||
|
||||
SOCKET sock;
|
||||
|
||||
/**
|
||||
Used for serialization. One per socket
|
||||
to make this threadsafe.
|
||||
*/
|
||||
BinaryOutput binaryOutput;
|
||||
|
||||
Conduit();
|
||||
|
||||
public:
|
||||
|
||||
virtual ~Conduit();
|
||||
uint64 bytesSent() const;
|
||||
uint64 messagesSent() const;
|
||||
uint64 bytesReceived() const;
|
||||
uint64 messagesReceived() const;
|
||||
|
||||
/**
|
||||
If true, receive will return true.
|
||||
*/
|
||||
virtual bool messageWaiting();
|
||||
|
||||
/**
|
||||
Returns the type of the waiting message (i.e. the type supplied
|
||||
with send). The return value is zero when there is no message
|
||||
waiting.
|
||||
|
||||
One way to use this is to have a Table mapping message types to
|
||||
pre-allocated subclasses so receiving looks like:
|
||||
|
||||
<PRE>
|
||||
// My base class for messages.
|
||||
class Message {
|
||||
virtual void serialize(BinaryOutput&) const;
|
||||
virtual void deserialize(BinaryInput&);
|
||||
virtual void process() = 0;
|
||||
};
|
||||
|
||||
Message* m = table[conduit->waitingMessageType()];
|
||||
conduit->receive(m);
|
||||
m->process();
|
||||
</PRE>
|
||||
|
||||
Another is to simply switch on the message type:
|
||||
|
||||
<pre>
|
||||
switch (conduit->waitingMessageType()) {
|
||||
case 0:
|
||||
// No message
|
||||
break;
|
||||
|
||||
case ENTITY_SPAWN_MSG:
|
||||
{
|
||||
EntitySpawnMsg m;
|
||||
condiut->receive(m);
|
||||
spawnEntity(m.id, m.position, m.modelID);
|
||||
}
|
||||
break;
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
*/
|
||||
virtual uint32 waitingMessageType() = 0;
|
||||
|
||||
/** Returns true if the connection is ok. */
|
||||
bool ok() const;
|
||||
};
|
||||
|
||||
typedef ReferenceCountedPointer<class ReliableConduit> ReliableConduitRef;
|
||||
|
||||
#ifdef __GNUC__
|
||||
// Workaround for a known bug in gcc 4.x where htonl produces
|
||||
// a spurrious warning.
|
||||
// http://gcc.gnu.org/ml/gcc-bugs/2005-10/msg03270.html
|
||||
uint32 gcchtonl(uint32);
|
||||
#endif
|
||||
|
||||
// Messaging and stream APIs must be supported on a single class because
|
||||
// sometimes an application will switch modes on a single socket. For
|
||||
// example, when transferring 3D level geometry during handshaking with
|
||||
// a game server.
|
||||
/**
|
||||
A conduit that guarantees messages will arrive, intact and in order.
|
||||
Create on the client using NetworkDevice::createReliableConduit and
|
||||
on the server using NetListener::waitForConnection. Set the reference
|
||||
counted pointer to NULL to disconnect.
|
||||
|
||||
To construct a ReliableConduit:
|
||||
<OL>
|
||||
<LI> Create a G3D::NetworkDevice (if you are using G3D::GApp, it creates
|
||||
one for you) on the client and on the server.
|
||||
<LI> On the server, create a G3D::NetListener using
|
||||
G3D::NetworkDevice::createListener
|
||||
<LI> On the server, invoke G3D::NetListener::waitForConnection.
|
||||
<LI> On the client, call G3D::NetworkDevice::createReliableConduit.
|
||||
You will need the server's G3D::NetAddress. Consider using
|
||||
G3D::DiscoveryClient to find it via broadcasting.
|
||||
</OL>
|
||||
|
||||
*/
|
||||
class ReliableConduit : public Conduit {
|
||||
private:
|
||||
friend class NetworkDevice;
|
||||
friend class NetListener;
|
||||
|
||||
enum State {RECEIVING, HOLDING, NO_MESSAGE} state;
|
||||
|
||||
NetAddress addr;
|
||||
|
||||
/**
|
||||
Type of the incoming message.
|
||||
*/
|
||||
uint32 messageType;
|
||||
|
||||
/**
|
||||
Total size of the incoming message (read from the header).
|
||||
*/
|
||||
uint32 messageSize;
|
||||
|
||||
/** Shared buffer for receiving messages. */
|
||||
void* receiveBuffer;
|
||||
|
||||
/** Total size of the receiveBuffer. */
|
||||
size_t receiveBufferTotalSize;
|
||||
|
||||
/** Size occupied by the current message... so far. This will be
|
||||
equal to messageSize when the whole message has arrived.
|
||||
*/
|
||||
size_t receiveBufferUsedSize;
|
||||
|
||||
ReliableConduit(const NetAddress& addr);
|
||||
|
||||
ReliableConduit(const SOCKET& sock,
|
||||
const NetAddress& addr);
|
||||
|
||||
template<typename T> static void serializeMessage
|
||||
(uint32 t, const T& m, BinaryOutput& b) {
|
||||
|
||||
b.writeUInt32(t);
|
||||
|
||||
// Reserve space for the 4 byte size header
|
||||
b.writeUInt32(0);
|
||||
|
||||
size_t L = b.length();
|
||||
m.serialize(b);
|
||||
if ((size_t)b.length() == L) {
|
||||
// No data was created by serialization.
|
||||
// We need to send at least one byte because receive assumes that
|
||||
// a zero length message is an error.
|
||||
b.writeUInt8(0xFF);
|
||||
}
|
||||
|
||||
uint32 len = b.size() - 8;
|
||||
|
||||
// We send the length first to tell recv how much data to read.
|
||||
// Here we abuse BinaryOutput a bit and write directly into
|
||||
// its buffer, violating the abstraction.
|
||||
// Note that we write to the second set of 4 bytes, which is
|
||||
// the size field.
|
||||
uint32* lenPtr = ((uint32*)b.getCArray()) + 1;
|
||||
#if defined(__GNUC__)
|
||||
*lenPtr = gcchtonl(len);
|
||||
#else
|
||||
*lenPtr = htonl(len);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void sendBuffer(const BinaryOutput& b);
|
||||
|
||||
/** Accumulates whatever part of the message (not the header) is
|
||||
still waiting on the socket into the receiveBuffer during
|
||||
state = RECEIVING mode. Closes the socket if anything goes
|
||||
wrong. When receiveBufferUsedSize == messageSize, the entire
|
||||
message has arrived. */
|
||||
void receiveIntoBuffer();
|
||||
|
||||
/** Receives the messageType and messageSize from the socket. */
|
||||
void receiveHeader();
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
Client invokes this to connect to a server. The call blocks until the
|
||||
conduit is opened. The conduit will not be ok() if it fails.
|
||||
*/
|
||||
static ReliableConduitRef create(const NetAddress& address);
|
||||
|
||||
/** Closes the socket. */
|
||||
~ReliableConduit();
|
||||
|
||||
|
||||
// The message is actually copied from the socket to an internal buffer during
|
||||
// this call. Receive only deserializes.
|
||||
virtual bool messageWaiting();
|
||||
|
||||
/**
|
||||
Serializes the message and schedules it to be sent as soon as possible,
|
||||
and then returns immediately. The message can be any <B>class</B> with
|
||||
a serialize and deserialize method. On the receiving side,
|
||||
use G3D::ReliableConduit::waitingMessageType() to detect the incoming
|
||||
message and then invoke G3D::ReliableConduit::receive(msg) where msg
|
||||
is of the same class as the message that was sent.
|
||||
|
||||
The actual data sent across the network is preceeded by the
|
||||
message type and the size of the serialized message as a 32-bit
|
||||
integer. The size is sent because TCP is a stream protocol and
|
||||
doesn't have a concept of discrete messages.
|
||||
*/
|
||||
template<typename T> inline void send(uint32 type, const T& message) {
|
||||
binaryOutput.reset();
|
||||
serializeMessage(type, message, binaryOutput);
|
||||
sendBuffer(binaryOutput);
|
||||
}
|
||||
|
||||
/** Sends an empty message with the given type. Useful for sending
|
||||
commands that have no parameters. */
|
||||
void send(uint32 type);
|
||||
|
||||
/** Send the same message to a number of conduits. Useful for sending
|
||||
data from a server to many clients (only serializes once). */
|
||||
template<typename T>
|
||||
inline static void multisend(
|
||||
const Array<ReliableConduitRef>& array,
|
||||
uint32 type,
|
||||
const T& m) {
|
||||
|
||||
if (array.size() > 0) {
|
||||
array[0]->binaryOutput.reset();
|
||||
serializeMessage(type, m, array[0]->binaryOutput);
|
||||
|
||||
for (int i = 0; i < array.size(); ++i) {
|
||||
array[i]->sendBuffer(array[0]->binaryOutput);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual uint32 waitingMessageType();
|
||||
|
||||
/**
|
||||
If a message is waiting, deserializes the waiting message into
|
||||
message and returns true, otherwise returns false. You can
|
||||
determine the type of the message (and therefore, the class
|
||||
of message) using G3D::ReliableConduit::waitingMessageType().
|
||||
*/
|
||||
template<typename T> inline bool receive(T& message) {
|
||||
if (! messageWaiting()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
debugAssert(state == HOLDING);
|
||||
// Deserialize
|
||||
BinaryInput b((uint8*)receiveBuffer, receiveBufferUsedSize, G3D_LITTLE_ENDIAN, BinaryInput::NO_COPY);
|
||||
message.deserialize(b);
|
||||
|
||||
// Don't let anyone read this message again. We leave the buffer
|
||||
// allocated for the next caller, however.
|
||||
receiveBufferUsedSize = 0;
|
||||
state = NO_MESSAGE;
|
||||
messageType = 0;
|
||||
messageSize = 0;
|
||||
|
||||
// Potentially read the next message.
|
||||
messageWaiting();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Removes the current message from the queue. */
|
||||
inline void receive() {
|
||||
if (! messageWaiting()) {
|
||||
return;
|
||||
}
|
||||
receiveBufferUsedSize = 0;
|
||||
state = NO_MESSAGE;
|
||||
messageType = 0;
|
||||
messageSize = 0;
|
||||
|
||||
// Potentially read the next message.
|
||||
messageWaiting();
|
||||
}
|
||||
|
||||
NetAddress address() const;
|
||||
};
|
||||
|
||||
|
||||
typedef ReferenceCountedPointer<class LightweightConduit> LightweightConduitRef;
|
||||
|
||||
/**
|
||||
Provides fast but unreliable transfer of messages. On a LAN,
|
||||
LightweightConduit will probably never drop messages but you
|
||||
<I>might</I> get your messages out of order. On an internet
|
||||
connection it might drop messages altogether. Messages are never
|
||||
corrupted, however. LightweightConduit requires a little less setup
|
||||
and overhead than ReliableConduit. ReliableConduit guarantees
|
||||
message delivery and order but requires a persistent connection.
|
||||
|
||||
To set up a LightweightConduit (assuming you have already made
|
||||
subclasses of G3D::NetMessage based on your application's
|
||||
pcommunication protocol):
|
||||
|
||||
[Server Side]
|
||||
<OL>
|
||||
<LI> Call LightweightConduit::create(port, true, false),
|
||||
where port is the port on which you will receive messages.
|
||||
|
||||
<LI> Poll LightweightConduit::messageWaiting from your main loop. When
|
||||
it is true (or, equivalently, when LightweightConduit::waitingMessageType
|
||||
is non-zero) there is an incoming message.
|
||||
|
||||
<LI> To read the incoming message, call LightweightConduit::receive with
|
||||
the appropriate class type, which mist have a deserialize method.
|
||||
LightweightConduit::waitingMessageType tells you what class is
|
||||
needed (you make up your own message constants for your program; numbers
|
||||
under 1000 are reserved for G3D's internal use).
|
||||
|
||||
<LI> When done, simply set the G3D::LightweightConduitRef to NULL or let
|
||||
it go out of scope and the conduit cleans itself up automatically.
|
||||
</OL>
|
||||
|
||||
[Client Side]
|
||||
<OL>
|
||||
<LI> Call G3D::LightweightConduit::create(). If you will
|
||||
broadcast to all servers on a LAN, set the third optional argument to
|
||||
true (the default is false for no broadcast). You can also set up the
|
||||
receive port as if it was a server to send and receive from a single
|
||||
LightweightConduit.
|
||||
|
||||
<LI> To send, call G3D::LightweightConduit::send with the target address
|
||||
and a pointer to an instance of the message you want to send.
|
||||
|
||||
<LI> When done, simply set the G3D::LightweightConduitRef to NULL or let
|
||||
it go out of scope and the conduit cleans itself up automatically.
|
||||
|
||||
</OL>
|
||||
*/
|
||||
class LightweightConduit : public Conduit {
|
||||
private:
|
||||
friend class NetworkDevice;
|
||||
|
||||
/**
|
||||
True when waitingForMessageType has read the message
|
||||
from the network into messageType/messageStream.
|
||||
*/
|
||||
bool alreadyReadMessage;
|
||||
|
||||
/**
|
||||
Origin of the received message.
|
||||
*/
|
||||
NetAddress messageSender;
|
||||
|
||||
/**
|
||||
The type of the last message received.
|
||||
*/
|
||||
uint32 messageType;
|
||||
|
||||
/**
|
||||
The message received (the type has already been read off).
|
||||
*/
|
||||
Array<uint8> messageBuffer;
|
||||
|
||||
LightweightConduit(uint16 receivePort, bool enableReceive, bool enableBroadcast);
|
||||
|
||||
void sendBuffer(const NetAddress& a, BinaryOutput& b);
|
||||
|
||||
/** Maximum transmission unit (packet size in bytes) for this socket.
|
||||
May vary between sockets. */
|
||||
int MTU;
|
||||
|
||||
|
||||
template<typename T>
|
||||
void serializeMessage(
|
||||
uint32 type,
|
||||
const T& m,
|
||||
BinaryOutput& b) const {
|
||||
|
||||
debugAssert(type != 0);
|
||||
b.writeUInt32(type);
|
||||
m.serialize(b);
|
||||
b.writeUInt32(1);
|
||||
|
||||
debugAssertM(b.size() < MTU,
|
||||
format("This LightweightConduit is limited to messages of "
|
||||
"%d bytes (Ethernet hardware limit; this is the "
|
||||
"'UDP MTU')", maxMessageSize()));
|
||||
|
||||
if (b.size() >= MTU) {
|
||||
throw LightweightConduit::PacketSizeException(
|
||||
format("This LightweightConduit is limited to messages of "
|
||||
"%d bytes (Ethernet hardware limit; this is the "
|
||||
"'UDP MTU')", maxMessageSize()),
|
||||
b.size() - 4, // Don't count the type header
|
||||
maxMessageSize());
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
static LightweightConduitRef create(uint16 receivePort, bool enableReceive, bool enableBroadcast);
|
||||
|
||||
class PacketSizeException {
|
||||
public:
|
||||
std::string message;
|
||||
int serializedPacketSize;
|
||||
int maxMessageSize;
|
||||
|
||||
inline PacketSizeException(const std::string& m, int s, int b) :
|
||||
message(m),
|
||||
serializedPacketSize(s),
|
||||
maxMessageSize(b) {}
|
||||
};
|
||||
|
||||
/** Closes the socket. */
|
||||
~LightweightConduit();
|
||||
|
||||
/** The maximum length of a message that can be sent
|
||||
(G3D places a small header at the front of each UDP packet;
|
||||
this is already taken into account by the value returned).
|
||||
*/
|
||||
inline int maxMessageSize() const {
|
||||
return MTU - 4;
|
||||
}
|
||||
|
||||
|
||||
template<typename T> inline void send(const NetAddress& a, uint32 type, const T& msg) {
|
||||
binaryOutput.reset();
|
||||
serializeMessage(type, msg, binaryOutput);
|
||||
sendBuffer(a, binaryOutput);
|
||||
}
|
||||
|
||||
/** Send the same message to multiple addresses (only serializes once).
|
||||
Useful when server needs to send to a known list of addresses
|
||||
(unlike direct UDP broadcast to all addresses on the subnet) */
|
||||
template<typename T> inline void send(const Array<NetAddress>& a, uint32 type, const T& m) {
|
||||
binaryOutput.reset();
|
||||
serializeMessage(type, m, binaryOutput);
|
||||
|
||||
for (int i = 0; i < a.size(); ++i) {
|
||||
sendBuffer(a[i], binaryOutput);
|
||||
}
|
||||
}
|
||||
|
||||
bool receive(NetAddress& sender);
|
||||
|
||||
template<typename T> inline bool receive(NetAddress& sender, T& message) {
|
||||
bool r = receive(sender);
|
||||
if (r) {
|
||||
BinaryInput b((messageBuffer.getCArray() + 4),
|
||||
messageBuffer.size() - 4,
|
||||
G3D_LITTLE_ENDIAN, BinaryInput::NO_COPY);
|
||||
message.deserialize(b);
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
inline bool receive() {
|
||||
static NetAddress ignore;
|
||||
return receive(ignore);
|
||||
}
|
||||
|
||||
virtual uint32 waitingMessageType();
|
||||
|
||||
|
||||
virtual bool messageWaiting();
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
typedef ReferenceCountedPointer<class NetListener> NetListenerRef;
|
||||
|
||||
/**
|
||||
Runs on the server listening for clients trying to make reliable connections.
|
||||
*/
|
||||
class NetListener : public ReferenceCountedObject {
|
||||
private:
|
||||
|
||||
friend class NetworkDevice;
|
||||
|
||||
SOCKET sock;
|
||||
|
||||
/** Port is in host byte order. */
|
||||
NetListener(uint16 port);
|
||||
|
||||
public:
|
||||
|
||||
static NetListenerRef create(const uint16 port);
|
||||
|
||||
~NetListener();
|
||||
|
||||
/** Block until a connection is received. Returns NULL if
|
||||
something went wrong. */
|
||||
ReliableConduitRef waitForConnection();
|
||||
|
||||
/** True if a client is waiting (i.e. waitForConnection will
|
||||
return immediately). */
|
||||
bool clientWaiting() const;
|
||||
|
||||
bool ok() const;
|
||||
};
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
@brief Abstraction of network (socket) functionality.
|
||||
|
||||
An abstraction over sockets that provides a message-based network
|
||||
infrastructure optimized for sending many small (~500 bytes) messages.
|
||||
All functions always return immediately.
|
||||
|
||||
Create only one NetworkDevice per process (a WinSock restriction).
|
||||
|
||||
NetworkDevice is technically not thread safe. However, as long as
|
||||
you use different conduits on different threads (or lock conduits
|
||||
before sending), you will encounter no problems sharing the single
|
||||
NetworkDevice across multiple threads. That is, do not invoke the same
|
||||
Conduit's send or receive method on two threads at once.
|
||||
|
||||
This assumes that the underlying WinSock/BSD sockets implementation
|
||||
is thread safe. That is not guaranteed, but in practice seems
|
||||
to always be true (see
|
||||
http://tangentsoft.net/wskfaq/intermediate.html#threadsafety)
|
||||
|
||||
<hr>
|
||||
|
||||
IP networks use "network byte order" (big-endian) for
|
||||
communicating integers. "Host byte order" is the endian-ness of
|
||||
the local machine (typically little-endian; see
|
||||
System::endian). The C functions htonl() and ntohl() convert 32-bit
|
||||
values between these formats. G3D only ever exposes host byte order,
|
||||
so programmers rarely need to be aware of the distinction.
|
||||
|
||||
*/
|
||||
class NetworkDevice {
|
||||
public:
|
||||
|
||||
/** @brief Description of an ethernet or wireless ethernet adapter.*/
|
||||
class EthernetAdapter {
|
||||
public:
|
||||
/** Reverse-DNS of the ip address.*/
|
||||
std::string hostname;
|
||||
|
||||
/** Name of the adapter */
|
||||
std::string name;
|
||||
|
||||
/** IP address in host byte order.*/
|
||||
uint32 ip;
|
||||
|
||||
/** Subnet mask in host byte order.*/
|
||||
uint32 subnet;
|
||||
|
||||
/** UDP broadcast address in host byte order.*/
|
||||
uint32 broadcast;
|
||||
|
||||
/** MAC (hardware) address, if known */
|
||||
uint8 mac[6];
|
||||
|
||||
EthernetAdapter();
|
||||
|
||||
/** Produces a text description of this adapter */
|
||||
void describe(TextOutput& t) const;
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
friend class Conduit;
|
||||
friend class LightweightConduit;
|
||||
friend class ReliableConduit;
|
||||
friend class NetListener;
|
||||
|
||||
bool initialized;
|
||||
|
||||
Array<EthernetAdapter> m_adapterArray;
|
||||
|
||||
/** Broadcast addresses available on this machine,
|
||||
extracted from m_adapterArray.*/
|
||||
Array<uint32> m_broadcastAddresses;
|
||||
|
||||
/** Utility method. */
|
||||
void closesocket(SOCKET& sock) const;
|
||||
|
||||
/** Utility method. Returns true on success.*/
|
||||
bool bind(SOCKET sock, const NetAddress& addr) const;
|
||||
|
||||
/** The global instance */
|
||||
static NetworkDevice* s_instance;
|
||||
|
||||
NetworkDevice();
|
||||
|
||||
bool init();
|
||||
|
||||
void _cleanup();
|
||||
|
||||
/** Called from init to update m_adapterArray and
|
||||
m_broadcastAddresses. */
|
||||
void addAdapter(const EthernetAdapter& a);
|
||||
|
||||
public:
|
||||
|
||||
/** Prints an IP address to a string.
|
||||
@param ip In host byte order.*/
|
||||
static std::string formatIP(uint32 ip);
|
||||
|
||||
/** Prints a MAC address to a string. */
|
||||
static std::string formatMAC(const uint8 mac[6]);
|
||||
|
||||
~NetworkDevice();
|
||||
|
||||
/** Returns the available ethernet adapters for the current
|
||||
machine that are online. Does not include the loopback adapter
|
||||
for localhost.*/
|
||||
inline const Array<EthernetAdapter>& adapterArray() const {
|
||||
return m_adapterArray;
|
||||
}
|
||||
|
||||
/** Returns the (unique) IP addresses for UDP broadcasting
|
||||
extracted from adapterArray(). All are in host byte order. */
|
||||
inline const Array<uint32>& broadcastAddressArray() const {
|
||||
return m_broadcastAddresses;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns NULL if there was a problem initializing the network.
|
||||
*/
|
||||
static NetworkDevice* instance();
|
||||
|
||||
/**
|
||||
Shuts down the network device (destroying the global instance).
|
||||
*/
|
||||
static void cleanup();
|
||||
|
||||
/**
|
||||
Prints a human-readable description of this machine
|
||||
to the text output stream.
|
||||
*/
|
||||
void describeSystem(
|
||||
TextOutput& t);
|
||||
|
||||
void describeSystem(
|
||||
std::string& s);
|
||||
|
||||
/** Returns the name (or one of the names) of this computer */
|
||||
std::string localHostName() const;
|
||||
|
||||
/** There is often more than one address for the local host. This
|
||||
returns all of them.
|
||||
@deprecated Use adapterArray()
|
||||
*/
|
||||
void localHostAddresses(Array<NetAddress>& array) const;
|
||||
};
|
||||
|
||||
|
||||
#ifdef __GNUC__
|
||||
inline uint32 gcchtonl(uint32 x) {
|
||||
// This pragma fools gcc into surpressing all error messages,
|
||||
// including the bogus one that it creates for htonl
|
||||
# pragma GCC system_header
|
||||
return htonl(x);
|
||||
}
|
||||
#endif
|
||||
|
||||
} // G3D namespace
|
||||
|
||||
#ifndef _WIN32
|
||||
#undef SOCKADDR_IN
|
||||
#undef SOCKET
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,74 @@
|
||||
/**
|
||||
@file PhysicsFrame.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2002-07-08
|
||||
@edited 2006-01-10
|
||||
*/
|
||||
|
||||
#ifndef G3D_PHYSICSFRAME_H
|
||||
#define G3D_PHYSICSFRAME_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Matrix3.h"
|
||||
#include "G3D/Quat.h"
|
||||
#include "G3D/CoordinateFrame.h"
|
||||
#include <math.h>
|
||||
#include <string>
|
||||
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
An RT transformation using a quaternion; suitable for
|
||||
physics integration.
|
||||
|
||||
This interface is in "Beta" and will change in the next release.
|
||||
*/
|
||||
class PhysicsFrame {
|
||||
public:
|
||||
|
||||
Quat rotation;
|
||||
|
||||
/**
|
||||
Takes object space points to world space.
|
||||
*/
|
||||
Vector3 translation;
|
||||
|
||||
/**
|
||||
Initializes to the identity frame.
|
||||
*/
|
||||
PhysicsFrame();
|
||||
|
||||
/**
|
||||
Purely translational force
|
||||
*/
|
||||
PhysicsFrame(const Vector3& translation) : translation(translation) {}
|
||||
|
||||
PhysicsFrame(const CoordinateFrame& coordinateFrame);
|
||||
|
||||
/** Compose: create the transformation that is <I>other</I> followed by <I>this</I>.*/
|
||||
PhysicsFrame operator*(const PhysicsFrame& other) const;
|
||||
|
||||
virtual ~PhysicsFrame() {}
|
||||
|
||||
CoordinateFrame toCoordinateFrame() const;
|
||||
|
||||
/**
|
||||
Linear interpolation (spherical linear for the rotations).
|
||||
*/
|
||||
PhysicsFrame lerp(
|
||||
const PhysicsFrame& other,
|
||||
float alpha) const;
|
||||
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
+161
@@ -0,0 +1,161 @@
|
||||
/**
|
||||
@file Plane.h
|
||||
|
||||
Plane class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2004-07-18
|
||||
*/
|
||||
|
||||
#ifndef G3D_PLANE_H
|
||||
#define G3D_PLANE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector4.h"
|
||||
#include "G3D/debugAssert.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
An infinite 2D plane in 3D space.
|
||||
*/
|
||||
class Plane {
|
||||
private:
|
||||
|
||||
/** normal.Dot(x,y,z) = distance */
|
||||
Vector3 _normal;
|
||||
float _distance;
|
||||
|
||||
/**
|
||||
Assumes the normal has unit length.
|
||||
*/
|
||||
Plane(const Vector3& n, float d) : _normal(n), _distance(d) {
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
Plane() : _normal(Vector3::unitY()), _distance(0) {
|
||||
}
|
||||
|
||||
/**
|
||||
Constructs a plane from three points.
|
||||
*/
|
||||
Plane(
|
||||
const Vector3& point0,
|
||||
const Vector3& point1,
|
||||
const Vector3& point2);
|
||||
|
||||
/**
|
||||
Constructs a plane from three points, where at most two are
|
||||
at infinity (w = 0, not xyz = inf).
|
||||
*/
|
||||
Plane(
|
||||
Vector4 point0,
|
||||
Vector4 point1,
|
||||
Vector4 point2);
|
||||
|
||||
/**
|
||||
The normal will be unitized.
|
||||
*/
|
||||
Plane(
|
||||
const Vector3& __normal,
|
||||
const Vector3& point);
|
||||
|
||||
static Plane fromEquation(float a, float b, float c, float d);
|
||||
|
||||
Plane(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
virtual ~Plane() {}
|
||||
|
||||
/**
|
||||
Returns true if point is on the side the normal points to or
|
||||
is in the plane.
|
||||
*/
|
||||
inline bool halfSpaceContains(Vector3 point) const {
|
||||
// Clamp to a finite range for testing
|
||||
point = point.clamp(Vector3::minFinite(), Vector3::maxFinite());
|
||||
|
||||
// We can get away with putting values *at* the limits of the float32 range into
|
||||
// a dot product, since the dot product is carried out on float64.
|
||||
return _normal.dot(point) >= _distance;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if point is on the side the normal points to or
|
||||
is in the plane.
|
||||
*/
|
||||
inline bool halfSpaceContains(const Vector4& point) const {
|
||||
if (point.w == 0) {
|
||||
return _normal.dot(point.xyz()) > 0;
|
||||
} else {
|
||||
return halfSpaceContains(point.xyz() / point.w);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if point is on the side the normal points to or
|
||||
is in the plane. Only call on finite points. Faster than halfSpaceContains.
|
||||
*/
|
||||
inline bool halfSpaceContainsFinite(const Vector3& point) const {
|
||||
debugAssert(point.isFinite());
|
||||
return _normal.dot(point) >= _distance;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if the point is nearly in the plane.
|
||||
*/
|
||||
inline bool fuzzyContains(const Vector3 &point) const {
|
||||
return fuzzyEq(point.dot(_normal), _distance);
|
||||
}
|
||||
|
||||
inline const Vector3& normal() const {
|
||||
return _normal;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns distance from point to plane. Distance is negative if point is behind (not in plane in direction opposite normal) the plane.
|
||||
*/
|
||||
inline float distance(const Vector3& x) const {
|
||||
return (_normal.dot(x) - _distance);
|
||||
}
|
||||
|
||||
inline Vector3 closestPoint(const Vector3& x) const {
|
||||
return x + (_normal * (-distance(x)));
|
||||
}
|
||||
|
||||
/** Returns normal * distance from origin */
|
||||
Vector3 center() const {
|
||||
return _normal * _distance;
|
||||
}
|
||||
|
||||
/**
|
||||
Inverts the facing direction of the plane so the new normal
|
||||
is the inverse of the old normal.
|
||||
*/
|
||||
void flip();
|
||||
|
||||
/**
|
||||
Returns the equation in the form:
|
||||
|
||||
<CODE>normal.Dot(Vector3(<I>x</I>, <I>y</I>, <I>z</I>)) + d = 0</CODE>
|
||||
*/
|
||||
void getEquation(Vector3 &normal, double& d) const;
|
||||
void getEquation(Vector3 &normal, float& d) const;
|
||||
|
||||
/**
|
||||
ax + by + cz + d = 0
|
||||
*/
|
||||
void getEquation(double& a, double& b, double& c, double& d) const;
|
||||
void getEquation(float& a, float& b, float& c, float& d) const;
|
||||
|
||||
std::string toString() const;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
+1207
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,894 @@
|
||||
/**
|
||||
@file PointHashGrid.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2008-07-01
|
||||
@edited 2008-11-02
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
#ifndef G3D_POINTHASHGRID_H
|
||||
#define G3D_POINTHASHGRID_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/EqualsTrait.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector3int32.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Table.h"
|
||||
#include "G3D/AABox.h"
|
||||
#include "G3D/Sphere.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Storage of data in a sparse 3D grid of point-based data. The
|
||||
space cost for <I>n</I> elements is O(<I>n</I>). For data with
|
||||
approximately uniform density (with respect to the radius hint),
|
||||
the time cost of searching for neighbors is O(1).
|
||||
|
||||
<i>Value</i> must be supported by a G3D::PositionTrait,
|
||||
G3D::EqualsTrait, and G3D::HashFunc. overrides are provided for
|
||||
common G3D classes like G3D::Vector3.
|
||||
*/
|
||||
template<class Value,
|
||||
class PosFunc = PositionTrait<Value>,
|
||||
class EqualsFunc = EqualsTrait<Value>,
|
||||
class HashFunc = HashTrait<Vector3int32> >
|
||||
class PointHashGrid {
|
||||
private:
|
||||
|
||||
#define ThisType PointHashGrid<Value, PosFunc, EqualsFunc, HashFunc>
|
||||
|
||||
/** A value annotated with precomputed position and hash code.*/
|
||||
class Entry {
|
||||
public:
|
||||
Vector3 position;
|
||||
Value value;
|
||||
};
|
||||
|
||||
/** One cell of the grid. */
|
||||
typedef Array<Entry> Cell;
|
||||
typedef Table<Vector3int32, Cell, HashFunc> CellTable;
|
||||
|
||||
/** The cube of +/-1 along each dimension. Initialized by initOffsetArray.*/
|
||||
Vector3int32 m_offsetArray[3*3*3];
|
||||
|
||||
/** Incremented every time the data structure is mutated.
|
||||
Used by the iterators to determine if the data structure
|
||||
has changed since iteration began. */
|
||||
int m_epoch;
|
||||
|
||||
/** Extent of a cell along one dimension. */
|
||||
float m_cellWidth;
|
||||
|
||||
/** Conservative bounds; the actual data may be smaller. */
|
||||
AABox m_bounds;
|
||||
|
||||
/** Number of elements. */
|
||||
int m_size;
|
||||
|
||||
/** Non-empty cells indexed by grid position. Actual 3D position is
|
||||
<code>position * m_cellWidth</code>*/
|
||||
CellTable m_data;
|
||||
|
||||
|
||||
/** Intentionally unimplemented: prevent copy construction. */
|
||||
PointHashGrid(const ThisType&);
|
||||
|
||||
|
||||
/** Intentionally unimplemented: prevent assignment. */
|
||||
PointHashGrid& operator=(const ThisType&);
|
||||
|
||||
|
||||
/** Locate the cell and index within that cell containing v. Called by
|
||||
remove() and contains(). */
|
||||
bool find(
|
||||
const Value& v,
|
||||
Vector3int32& foundCellCoord,
|
||||
Cell*& foundCell,
|
||||
int& index) {
|
||||
|
||||
Vector3 pos;
|
||||
PosFunc::getPosition(v, pos);
|
||||
|
||||
Vector3int32 cellCoord;
|
||||
getCellCoord(pos, cellCoord);
|
||||
for (int i = 0; i < 27; ++i) {
|
||||
Vector3int32 c = cellCoord + m_offsetArray[i];
|
||||
Cell* cell = m_data.getPointer(c);
|
||||
if (cell != NULL) {
|
||||
// The cell exists
|
||||
for (int j = 0; j < cell->size(); ++j) {
|
||||
if (EqualsFunc::equals((*cell)[j].value, v)) {
|
||||
foundCell = cell;
|
||||
index = j;
|
||||
foundCellCoord = c;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Not found
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Given a real-space position, returns the cell coord
|
||||
containing it.*/
|
||||
void getCellCoord(const Vector3& pos, Vector3int32& cellCoord) const {
|
||||
for (int a = 0; a < 3; ++a) {
|
||||
cellCoord[a] = iFloor(pos[a] / m_cellWidth);
|
||||
}
|
||||
}
|
||||
|
||||
/** Initializes m_offsetArray. */
|
||||
void initOffsetArray() {
|
||||
int i = 0;
|
||||
Vector3int32 d;
|
||||
for (d.x = -1; d.x <= +1; ++d.x) {
|
||||
for (d.y = -1; d.y <= +1; ++d.y) {
|
||||
for (d.z = -1; d.z <= +1; ++d.z) {
|
||||
m_offsetArray[i] = d;
|
||||
++i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Put (0, 0, 0) first, so that contains() is most likely to find
|
||||
// the value quickly.
|
||||
i = (1 * 3 + 1) * 3 + 1;
|
||||
debugAssert(m_offsetArray[i] == Vector3int32(0,0,0));
|
||||
Vector3int32 temp = m_offsetArray[0];
|
||||
m_offsetArray[0] = m_offsetArray[i];
|
||||
m_offsetArray[i] = temp;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
@param radiusHint the radius that will typically be used with
|
||||
beginSphereIntersection and beginBoxIntersection. If two <i>Value</i>s are equal,
|
||||
their positions must be within this radius as well.
|
||||
*/
|
||||
PointHashGrid(float radiusHint) : m_size(0) {
|
||||
initOffsetArray();
|
||||
|
||||
debugAssertM(radiusHint > 0, "Cell radius must be positive");
|
||||
m_cellWidth = radiusHint;
|
||||
}
|
||||
|
||||
/**
|
||||
If radiusHint is negative, it is automatically chosen to put
|
||||
about 5 values in each grid cell (which means about 27 * 5
|
||||
values for each beginIntersection call).
|
||||
*/
|
||||
PointHashGrid(const Array<Value>& init, float radiusHint = -1.0f) : m_size(0) {
|
||||
initOffsetArray();
|
||||
|
||||
Vector3 lo(Vector3::inf());
|
||||
Vector3 hi(-lo);
|
||||
|
||||
// Compute bounds
|
||||
Array<Entry> entry(init.size());
|
||||
for (int i = 0; i < entry.size(); ++i) {
|
||||
const Value& value = init[i];
|
||||
Vector3 pos = m_posFunc(value);
|
||||
|
||||
entry[i].value = value;
|
||||
entry[i].hashCode = m_hashFunc(value);
|
||||
entry[i].position = pos;
|
||||
|
||||
lo = lo.min(pos);
|
||||
hi = hi.max(pos);
|
||||
}
|
||||
|
||||
m_bounds = AABox(lo, hi);
|
||||
|
||||
if (radiusHint <= 0) {
|
||||
// Compute a good cell width based on the bounds.
|
||||
//
|
||||
// N numPerCell
|
||||
// ----- = ---------
|
||||
// volume r^3
|
||||
|
||||
float numPerCell = 5;
|
||||
radiusHint =
|
||||
(float)pow(numPerCell * m_bounds.volume() / init.size(), 1.0 / 3.0);
|
||||
|
||||
if (radiusHint == 0) {
|
||||
// Volume must have been zero because all points were colocated.
|
||||
radiusHint = 0.1f;
|
||||
}
|
||||
}
|
||||
|
||||
insert(init);
|
||||
}
|
||||
|
||||
/** Returns the number of elements. */
|
||||
inline int size() const {
|
||||
return m_size;
|
||||
}
|
||||
|
||||
/** Returns a conservative bounding box around the contents. This is
|
||||
conservative because it is not updated when elements are removed. */
|
||||
const AABox& conservativeBoxBounds() const {
|
||||
return m_bounds;
|
||||
}
|
||||
|
||||
/** Insert @a v at position @a p given by <code>getPosition(v, p)</code>.
|
||||
Multiple elements that are equal may be inserted; all copies will be
|
||||
in the data structure. */
|
||||
void insert(const Value& v) {
|
||||
Vector3 pos;
|
||||
PosFunc::getPosition(v, pos);
|
||||
Vector3int32 cellCoord;
|
||||
getCellCoord(pos, cellCoord);
|
||||
|
||||
// See if the cell already exists
|
||||
Cell* cell = m_data.getPointer(cellCoord);
|
||||
|
||||
if (cell == NULL) {
|
||||
// The cell did not exist; create it
|
||||
m_data.set(cellCoord, Cell());
|
||||
cell = m_data.getPointer(cellCoord);
|
||||
}
|
||||
debugAssert(cell != NULL);
|
||||
|
||||
Entry& entry = cell->next();
|
||||
entry.value = v;
|
||||
entry.position = pos;
|
||||
|
||||
// Update the bounds
|
||||
if (size() == 0) {
|
||||
m_bounds = AABox(pos);
|
||||
} else {
|
||||
m_bounds.merge(pos);
|
||||
}
|
||||
|
||||
++m_size;
|
||||
++m_epoch;
|
||||
}
|
||||
|
||||
|
||||
/** Inserts all elements of the array. */
|
||||
void insert(const Array<Value>& v) {
|
||||
for (int i = 0; i < v.size(); ++i) {
|
||||
insert(v[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** If there are multiple copies of an element, you must
|
||||
delete them multiple times.
|
||||
|
||||
@param shrinkAsNeeded If <b>true</b>, deallocate underlying data
|
||||
structures as they are emptied. False increases performace at
|
||||
the cost of memory overhead for dynamic structures.
|
||||
|
||||
@return true if the element was found.
|
||||
*/
|
||||
bool remove(const Value& v, bool shrinkIfNecessary = true) {
|
||||
Cell* cell = NULL;
|
||||
int index = 0;
|
||||
Vector3int32 cellCoord;
|
||||
|
||||
if (find(v, cellCoord, cell, index)) {
|
||||
cell->fastRemove(index, shrinkIfNecessary);
|
||||
--m_size;
|
||||
++m_epoch;
|
||||
|
||||
if ((cell->size() == 0) && shrinkIfNecessary) {
|
||||
// Remove the cell itself
|
||||
|
||||
// Drop our pointer, which is about to dangle
|
||||
cell = NULL;
|
||||
bool success = m_data.remove(cellCoord);
|
||||
debugAssertM(success, "Data structure corrupt: "
|
||||
"tried to remove a cell that doesn't exist.");
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Removes all elements of @v. */
|
||||
void remove(const Array<Value>& v, bool shrink = true) {
|
||||
for (int i = 0; i < v.size(); ++i) {
|
||||
remove(v[i], shrink);
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class Iterator {
|
||||
private:
|
||||
friend class ThisType;
|
||||
|
||||
bool m_isEnd;
|
||||
|
||||
const ThisType* m_grid;
|
||||
|
||||
typename CellTable::Iterator m_tableIterator;
|
||||
|
||||
/** Index within m_tableIterator->value of the current value. */
|
||||
int m_arrayIndex;
|
||||
|
||||
const int m_epoch;
|
||||
|
||||
/** End iterator. Note that the m_tableIterator is initialized to the end iterator
|
||||
of a temporary value! This is ok because we'll never look at the value of the
|
||||
m_tableIterator, since we're initializing the "end" Iterator.*/
|
||||
Iterator() : m_isEnd(true), m_grid(NULL), m_tableIterator(CellTable().end()),
|
||||
m_arrayIndex(0), m_epoch(0) {}
|
||||
|
||||
Iterator(const ThisType* grid) :
|
||||
m_isEnd(false),
|
||||
m_grid(grid),
|
||||
m_tableIterator( grid->m_data.begin() ),
|
||||
m_arrayIndex(0),
|
||||
m_epoch(grid->m_epoch) { }
|
||||
|
||||
private:
|
||||
|
||||
const Value& value() const {
|
||||
debugAssert(! m_isEnd);
|
||||
debugAssertM(m_tableIterator->value.size() > m_arrayIndex,
|
||||
"No more elements");
|
||||
return m_tableIterator->value[m_arrayIndex].value;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
inline bool operator!=(const Iterator& other) const {
|
||||
if (other.m_isEnd && m_isEnd) {
|
||||
return false;
|
||||
} else {
|
||||
return (m_isEnd != other.m_isEnd) ||
|
||||
(m_tableIterator != other.m_tableIterator) ||
|
||||
(m_arrayIndex != other.m_arrayIndex);
|
||||
}
|
||||
}
|
||||
|
||||
bool operator==(const Iterator& other) const {
|
||||
return !(*this != other);
|
||||
}
|
||||
|
||||
/** Preincrement */
|
||||
Iterator& operator++() {
|
||||
debugAssert(! m_isEnd);
|
||||
debugAssertM(m_epoch == m_grid->m_epoch,
|
||||
"It is illegal to mutate the HashGrid "
|
||||
"while iterating through it.");
|
||||
|
||||
++m_arrayIndex;
|
||||
|
||||
if (m_arrayIndex >= m_tableIterator->value.size()) {
|
||||
// Move on to the next cell
|
||||
++m_tableIterator;
|
||||
m_arrayIndex = 0;
|
||||
|
||||
// Check to see if we're at the end
|
||||
m_isEnd = (m_tableIterator == m_grid->m_data.end());
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** Post increment (slower) */
|
||||
Iterator operator++(int) {
|
||||
debugAssert(! m_isEnd);
|
||||
Iterator old = *this;
|
||||
++(*this);
|
||||
return old;
|
||||
}
|
||||
|
||||
const Value& operator*() const { return value(); }
|
||||
const Value* operator->() const { return &value(); }
|
||||
operator Value*() const { return &value(); }
|
||||
}; // Iterator
|
||||
|
||||
|
||||
/** Iterate through all members. It is an error to mutate the HashGrid
|
||||
while iterating through it. Each member can be accessed by "dereferencing"
|
||||
the iterator:
|
||||
|
||||
<pre>
|
||||
for (Grid::Iterator i = grid.begin(); i != grid.end(), ++i) {
|
||||
const Value& = *i;
|
||||
...
|
||||
}
|
||||
</pre>
|
||||
*/
|
||||
Iterator begin() const {
|
||||
return Iterator(this);
|
||||
}
|
||||
|
||||
const Iterator& end() const {
|
||||
static const Iterator it;
|
||||
return it;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Forward declaration required by older gcc versions for friend declaration in BoxIterator
|
||||
class SphereIterator;
|
||||
class BoxIterator {
|
||||
private:
|
||||
friend class ThisType;
|
||||
friend class SphereIterator;
|
||||
|
||||
bool m_isEnd;
|
||||
|
||||
const ThisType* m_grid;
|
||||
|
||||
/** Lower bound on the boxes covered, inclusive. */
|
||||
Vector3int32 m_lo;
|
||||
|
||||
/** Upper bound on the boxes covered, inclusive.*/
|
||||
Vector3int32 m_hi;
|
||||
|
||||
/** If true, test values against m_box before returning them.*/
|
||||
bool m_exact;
|
||||
|
||||
/** The underlying box in 3D space */
|
||||
AABox m_box;
|
||||
|
||||
/** The iterator winds through the 3D grid between m_lo and (m_lo + m_extent) in
|
||||
Z,Y,X-major order. This is the index keeping track of how
|
||||
far it has come */
|
||||
Vector3int32 m_current;
|
||||
|
||||
/** The current cell. */
|
||||
Cell* m_cell;
|
||||
|
||||
/** Index within m_cell of the current value */
|
||||
int m_arrayIndex;
|
||||
|
||||
const int m_epoch;
|
||||
|
||||
|
||||
/** Called from advance() */
|
||||
void advanceCell() {
|
||||
do {
|
||||
++m_current.x;
|
||||
if (m_current.x > m_hi.x) {
|
||||
m_current.x = m_lo.x;
|
||||
++m_current.y;
|
||||
if (m_current.y > m_hi.y) {
|
||||
m_current.y = m_lo.y;
|
||||
++m_current.z;
|
||||
if (m_current.z > m_hi.z) {
|
||||
m_isEnd = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pick up the new cell
|
||||
m_cell = m_grid->m_data.getPointer(m_current);
|
||||
// Keep advancing if the cell does not exist
|
||||
} while ((m_cell == NULL) || (m_cell->size() == 0));
|
||||
}
|
||||
|
||||
/** Advance to the next value */
|
||||
void advance() {
|
||||
debugAssert(! m_isEnd);
|
||||
|
||||
do {
|
||||
++m_arrayIndex;
|
||||
bool inConstructor = (m_cell == NULL);
|
||||
if (inConstructor || m_arrayIndex >= m_cell->size()) {
|
||||
advanceCell();
|
||||
m_arrayIndex = 0;
|
||||
|
||||
if (m_isEnd) {
|
||||
// Ran out of values
|
||||
return;
|
||||
}
|
||||
debugAssert(m_cell != NULL);
|
||||
}
|
||||
|
||||
// Advance until we have a value that can be returned, either
|
||||
// because we don't care about exactness or because it is
|
||||
// guaranteed to be within the box.
|
||||
} while (m_exact && ! m_box.contains(position()));
|
||||
}
|
||||
|
||||
|
||||
/** End iterator */
|
||||
BoxIterator() : m_isEnd(true), m_grid(NULL), m_exact(true), m_current(0,0,0), m_cell(NULL), m_arrayIndex(0), m_epoch(0) {}
|
||||
|
||||
/** Begin iterator */
|
||||
BoxIterator(const ThisType* grid, bool exact, const AABox& box) :
|
||||
m_isEnd(false),
|
||||
m_grid(grid),
|
||||
m_exact(exact),
|
||||
m_box(box),
|
||||
m_current(-1, 0 ,0),
|
||||
m_cell(NULL),
|
||||
m_arrayIndex(0),
|
||||
m_epoch(grid->m_epoch) {
|
||||
|
||||
m_grid->getCellCoord(box.low(), m_lo);
|
||||
m_grid->getCellCoord(box.high(), m_hi);
|
||||
|
||||
// Get to the first value
|
||||
m_current = m_lo;
|
||||
// Back up one so that advancing takes us to the first
|
||||
--m_current.x;
|
||||
advance();
|
||||
}
|
||||
|
||||
const Value& value() const {
|
||||
debugAssert(! m_isEnd);
|
||||
return (*m_cell)[m_arrayIndex].value;
|
||||
}
|
||||
|
||||
/** Used by SphereIterator::advance() */
|
||||
const Vector3& position() const {
|
||||
debugAssert(! m_isEnd);
|
||||
return (*m_cell)[m_arrayIndex].position;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
inline bool operator!=(const BoxIterator& other) const {
|
||||
if (other.m_isEnd && m_isEnd) {
|
||||
return false;
|
||||
} else {
|
||||
return (m_isEnd != other.m_isEnd) ||
|
||||
(m_cell != other.m_cell) ||
|
||||
(m_arrayIndex != other.m_arrayIndex);
|
||||
}
|
||||
}
|
||||
|
||||
bool operator==(const BoxIterator& other) const {
|
||||
return !(*this != other);
|
||||
}
|
||||
|
||||
/** Preincrement */
|
||||
BoxIterator& operator++() {
|
||||
debugAssert(! m_isEnd);
|
||||
debugAssertM(m_epoch == m_grid->m_epoch,
|
||||
"It is illegal to mutate the HashGrid "
|
||||
"while iterating through it.");
|
||||
|
||||
advance();
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** Post increment (slower) */
|
||||
BoxIterator operator++(int) {
|
||||
Iterator old = *this;
|
||||
++(*this);
|
||||
return old;
|
||||
}
|
||||
|
||||
const Value& operator*() const { return value(); }
|
||||
const Value* operator->() const { return &value(); }
|
||||
operator Value*() const { return &value(); }
|
||||
|
||||
bool hasMore() const {
|
||||
return ! m_isEnd;
|
||||
}
|
||||
}; // BoxIterator
|
||||
|
||||
/**
|
||||
Finds all values whose positions are within @a box. It is an error to
|
||||
mutate the PointHashGrid while iterating through it.
|
||||
|
||||
@param exact If false, the iterator will execute more quickly but will likely return some
|
||||
values that lie outside the box. Set exact = false if you are going to test the
|
||||
results against the yourself box anyway.
|
||||
*/
|
||||
BoxIterator beginBoxIntersection(const AABox& box, bool exact = true) const {
|
||||
return BoxIterator(this, exact, box);
|
||||
}
|
||||
|
||||
const BoxIterator& endBoxIntersection() const {
|
||||
static const BoxIterator it;
|
||||
return it;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class SphereIterator {
|
||||
private:
|
||||
|
||||
friend class ThisType;
|
||||
|
||||
bool m_isEnd;
|
||||
Sphere m_sphere;
|
||||
BoxIterator m_boxIterator;
|
||||
|
||||
SphereIterator() : m_isEnd(true) {}
|
||||
|
||||
void advance() {
|
||||
if (! m_boxIterator.hasMore()) {
|
||||
m_isEnd = true;
|
||||
return;
|
||||
}
|
||||
|
||||
while (! m_sphere.contains(m_boxIterator.position())) {
|
||||
++m_boxIterator;
|
||||
|
||||
if (! m_boxIterator.hasMore()) {
|
||||
m_isEnd = true;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static AABox getBoundingBox(const Sphere& s) {
|
||||
AABox box;
|
||||
s.getBounds(box);
|
||||
return box;
|
||||
}
|
||||
|
||||
SphereIterator(const ThisType* grid, const Sphere& sphere) :
|
||||
m_isEnd(false),
|
||||
m_sphere(sphere),
|
||||
m_boxIterator(grid, false, getBoundingBox(sphere)) {
|
||||
|
||||
// Find the first element that is actually in the sphere,
|
||||
// not just the box.
|
||||
advance();
|
||||
}
|
||||
|
||||
const Value& value() const {
|
||||
return *m_boxIterator;
|
||||
}
|
||||
|
||||
// TODO: if the sphere is very big compared to radius, check each
|
||||
// cell's box to see if the cell itself is actually inside the sphere
|
||||
// before iterating through it, since there may be many boxes outside the sphere.
|
||||
|
||||
public:
|
||||
|
||||
inline bool operator!=(const SphereIterator& other) const {
|
||||
if (other.m_isEnd && m_isEnd) {
|
||||
return false;
|
||||
} else {
|
||||
return
|
||||
(m_isEnd != other.m_isEnd) ||
|
||||
(m_sphere != other.m_sphere) ||
|
||||
(m_boxIterator != other.m_boxIterator);
|
||||
}
|
||||
}
|
||||
|
||||
bool operator==(const SphereIterator& other) const {
|
||||
return !(*this != other);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/** Preincrement */
|
||||
SphereIterator& operator++() {
|
||||
debugAssert(! m_isEnd);
|
||||
|
||||
++m_boxIterator;
|
||||
advance();
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** Post increment (slower) */
|
||||
SphereIterator operator++(int) {
|
||||
Iterator old = *this;
|
||||
++(*this);
|
||||
return old;
|
||||
}
|
||||
|
||||
const Value& operator*() const { return value(); }
|
||||
const Value* operator->() const { return &value(); }
|
||||
operator Value*() const { return &value(); }
|
||||
|
||||
bool hasMore() const {
|
||||
return ! m_isEnd;
|
||||
}
|
||||
}; // SphereIterator
|
||||
|
||||
/**
|
||||
Finds all values whose positions are within @a sphere. It is an error
|
||||
to mutate the HashGrid while iterating through it.
|
||||
*/
|
||||
SphereIterator beginSphereIntersection(const Sphere& sphere) const {
|
||||
return SphereIterator(this, sphere);
|
||||
}
|
||||
|
||||
const SphereIterator& endSphereIntersection() const {
|
||||
static const SphereIterator it;
|
||||
return it;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**
|
||||
Dereference to access the bounds() and size() [element count] of the underlying
|
||||
cell objet.
|
||||
|
||||
Example:
|
||||
<pre>
|
||||
for(PointHashGrid<Vector3>::CellIterator iter = grid.beginCells(); iter != grid.endCells(); ++iter) {
|
||||
entriesFound += iter->size();
|
||||
}
|
||||
*/
|
||||
class CellIterator {
|
||||
private:
|
||||
friend class ThisType;
|
||||
|
||||
bool m_isEnd;
|
||||
const ThisType* m_grid;
|
||||
typename CellTable::Iterator m_tableIterator;
|
||||
const int m_epoch;
|
||||
|
||||
|
||||
Cell& cell() {
|
||||
return m_tableIterator->value;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
class CellObject {
|
||||
friend class CellIterator;
|
||||
private:
|
||||
const CellIterator* m_parent;
|
||||
|
||||
CellObject() : m_parent(NULL) {}
|
||||
|
||||
public:
|
||||
|
||||
/** Returns the bounds on this cell */
|
||||
AABox bounds() const {
|
||||
const Vector3int32& k = m_parent->m_tableIterator->key;
|
||||
return AABox(Vector3(k) * m_parent->m_cellWidth,
|
||||
Vector3(k + Vector3int32(1, 1, 1)) * m_parent->m_cellWidth);
|
||||
}
|
||||
|
||||
/** Number of elements inside this cell */
|
||||
int size() const {
|
||||
debugAssert(! m_parent->m_isEnd);
|
||||
return m_parent->m_tableIterator->value.size();
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
/** Used to make the indirection work.*/
|
||||
CellObject m_indirection;
|
||||
|
||||
/** End iterator. Note that the m_tableIterator is initialized to the end iterator
|
||||
of a temporary value! This is ok because we'll never look at the value of the
|
||||
m_tableIterator, since we're initializing the "end" Iterator.*/
|
||||
CellIterator() :
|
||||
m_isEnd(true),
|
||||
m_grid(NULL),
|
||||
m_tableIterator( CellTable().end() ),
|
||||
m_epoch(0) {}
|
||||
|
||||
CellIterator(const ThisType* grid) :
|
||||
m_isEnd(false),
|
||||
m_grid(grid),
|
||||
m_tableIterator( grid->m_data.begin()),
|
||||
m_epoch(grid->m_epoch) {
|
||||
m_indirection.m_parent = this;
|
||||
m_isEnd = ! m_tableIterator.hasMore();
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
const CellObject& operator*() const { return m_indirection; }
|
||||
const CellObject* operator->() const { return &m_indirection; }
|
||||
operator CellObject*() const { return &m_indirection; }
|
||||
|
||||
inline bool operator!=(const CellIterator& other) const {
|
||||
// != is called more often than == during iteration
|
||||
return !(
|
||||
(m_isEnd && other.m_isEnd) ||
|
||||
((m_isEnd == other.m_isEnd) &&
|
||||
(m_tableIterator != other.m_tableIterator)));
|
||||
}
|
||||
|
||||
bool operator==(const CellIterator& other) const {
|
||||
return !(*this != other);
|
||||
}
|
||||
|
||||
/** Preincrement */
|
||||
CellIterator& operator++() {
|
||||
debugAssertM(m_epoch == m_grid->m_epoch,
|
||||
"It is illegal to mutate the HashGrid while "
|
||||
"iterating through it.");
|
||||
++m_tableIterator;
|
||||
m_isEnd = ! m_tableIterator.hasMore();
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** Post increment (slower) */
|
||||
CellIterator operator++(int) {
|
||||
Iterator old = *this;
|
||||
++(*this);
|
||||
return old;
|
||||
}
|
||||
|
||||
bool hasMore() const {
|
||||
return ! m_isEnd;
|
||||
}
|
||||
}; // CellIterator
|
||||
|
||||
/** Iterates through the non-empty cells. This is intended primarily for
|
||||
debugging and visualizing the data structure.*/
|
||||
CellIterator beginCells() const {
|
||||
return CellIterator(this);
|
||||
}
|
||||
|
||||
const CellIterator& endCells() const {
|
||||
static const CellIterator it;
|
||||
return it;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/** Returns true if there is a value that is exactly equal to @a. This will
|
||||
check all neighboring cells to avoid roundoff error at cell boundaries.
|
||||
*/
|
||||
bool contains(const Value& v) const {
|
||||
Cell* cell = NULL;
|
||||
int index = 0;
|
||||
Vector3int32 cellCoord;
|
||||
return const_cast<ThisType*>(this)->find(v, cellCoord, cell, index);
|
||||
}
|
||||
|
||||
/** Calls delete on all of the values, which are assumed to be pointers.
|
||||
This is a helper to avoid requiring you to iterate through the data
|
||||
structure, removing and deleting each one. Clears the PointHashGrid at the
|
||||
end.
|
||||
|
||||
Using objects (instead of pointers) or reference counted pointers is
|
||||
recommended over using pointers and this deleteAll method.*/
|
||||
void deleteAll() {
|
||||
for (Iterator it = begin(); it.hasMore(); ++it) {
|
||||
delete *it;
|
||||
}
|
||||
clear();
|
||||
}
|
||||
|
||||
/** Removes all data.
|
||||
@param shrink If true, underlying structures are deallocated as
|
||||
they are freed.*/
|
||||
void clear(bool shrink = true) {
|
||||
m_size = 0;
|
||||
m_bounds = AABox();
|
||||
if (! shrink) {
|
||||
// Remove all data
|
||||
for (CellIterator it = beginCells(); it.hasMore(); ++it) {
|
||||
it.cell().clear(true);
|
||||
}
|
||||
} else {
|
||||
m_data.clear();
|
||||
}
|
||||
++m_epoch;
|
||||
}
|
||||
|
||||
int debugGetDeepestBucketSize() const {
|
||||
return m_data.debugGetDeepestBucketSize();
|
||||
}
|
||||
|
||||
float debugGetAverageBucketSize() const {
|
||||
return m_data.debugGetAverageBucketSize();
|
||||
}
|
||||
#undef ThisType
|
||||
};
|
||||
|
||||
} // G3D
|
||||
#endif
|
||||
+275
@@ -0,0 +1,275 @@
|
||||
/**
|
||||
@file Pointer.h
|
||||
|
||||
@maintainer Morgan McGuire, graphics3d.com
|
||||
|
||||
@created 2007-05-16
|
||||
@edited 2007-06-22
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
#ifndef G3D_POINTER_H
|
||||
#define G3D_POINTER_H
|
||||
|
||||
#include "G3D/debugAssert.h"
|
||||
#include "G3D/ReferenceCount.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Acts like a pointer to a value of type ValueType (i.e.,
|
||||
ValueType*), but can operate through accessor methods as well as on
|
||||
a value in memory. This is useful for implementing scripting
|
||||
languages and other applications that need to connect existing APIs
|
||||
by reference.
|
||||
|
||||
Because the accessors require values to be passed by value (instead of by reference)
|
||||
this is primarily useful for objects whose memory size is small.
|
||||
|
||||
<pre>
|
||||
class Foo {
|
||||
public:
|
||||
void setEnabled(bool b);
|
||||
bool getEnabled() const;
|
||||
};
|
||||
|
||||
Foo f;
|
||||
bool b;
|
||||
|
||||
Pointer<bool> p1(&b);
|
||||
Pointer<bool> p2(&f, &Foo::getEnabled, &Foo::setEnabled);
|
||||
|
||||
*p1 = true;
|
||||
*p2 = false;
|
||||
*p2 = *p1; \/\/ Value assignment
|
||||
p2 = p1; \/\/ Pointer aliasing
|
||||
|
||||
\/\/ Or, equivalently:
|
||||
p1.setValue(true);
|
||||
p2.setValue(false);
|
||||
|
||||
p2.setValue(p1.getValue());
|
||||
p2 = p1;
|
||||
</pre>
|
||||
|
||||
<i>Note:</i> Because of the way that dereference is implemented, you cannot pass <code>*p</code> through a function
|
||||
that takes varargs (...), e.g., <code>printf("%d", *p)</code> will produce a compile-time error. Instead use
|
||||
<code>printf("%d",(bool)*p)</code> or <code>printf("%d", p.getValue())</code>.
|
||||
|
||||
*/
|
||||
template<class ValueType>
|
||||
class Pointer {
|
||||
private:
|
||||
|
||||
class Interface {
|
||||
public:
|
||||
virtual ~Interface() {};
|
||||
virtual void set(ValueType b) = 0;
|
||||
virtual ValueType get() const = 0;
|
||||
virtual Interface* clone() const = 0;
|
||||
};
|
||||
|
||||
class Memory : public Interface {
|
||||
private:
|
||||
|
||||
ValueType* value;
|
||||
|
||||
public:
|
||||
|
||||
Memory(ValueType* value) : value(value) {
|
||||
debugAssert(value != NULL);
|
||||
}
|
||||
|
||||
virtual void set(ValueType v) {
|
||||
*value = v;
|
||||
}
|
||||
|
||||
virtual ValueType get() const {
|
||||
return *value;
|
||||
}
|
||||
|
||||
virtual Interface* clone() const {
|
||||
return new Memory(value);
|
||||
}
|
||||
};
|
||||
|
||||
template<class T, typename GetMethod, typename SetMethod>
|
||||
class Accessor : public Interface {
|
||||
private:
|
||||
|
||||
T* object;
|
||||
GetMethod getMethod;
|
||||
SetMethod setMethod;
|
||||
|
||||
public:
|
||||
|
||||
Accessor(T* object,
|
||||
GetMethod getMethod,
|
||||
SetMethod setMethod) : object(object), getMethod(getMethod), setMethod(setMethod) {
|
||||
debugAssert(object != NULL);
|
||||
}
|
||||
|
||||
virtual void set(ValueType v) {
|
||||
(object->*setMethod)(v);
|
||||
}
|
||||
|
||||
virtual ValueType get() const {
|
||||
return (object->*getMethod)();
|
||||
}
|
||||
|
||||
virtual Interface* clone() const {
|
||||
return new Accessor(object, getMethod, setMethod);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class T, typename GetMethod, typename SetMethod>
|
||||
class RefAccessor : public Interface {
|
||||
private:
|
||||
|
||||
ReferenceCountedPointer<T> object;
|
||||
GetMethod getMethod;
|
||||
SetMethod setMethod;
|
||||
|
||||
public:
|
||||
|
||||
RefAccessor(
|
||||
const ReferenceCountedPointer<T>& object,
|
||||
GetMethod getMethod,
|
||||
SetMethod setMethod) : object(object), getMethod(getMethod), setMethod(setMethod) {
|
||||
|
||||
debugAssert(object != NULL);
|
||||
}
|
||||
|
||||
virtual void set(ValueType v) {
|
||||
(object.pointer()->*setMethod)(v);
|
||||
}
|
||||
|
||||
virtual ValueType get() const {
|
||||
return (object.pointer()->*getMethod)();
|
||||
}
|
||||
|
||||
virtual Interface* clone() const {
|
||||
return new RefAccessor(object, getMethod, setMethod);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
Interface* interface;
|
||||
|
||||
public:
|
||||
|
||||
Pointer() : interface(NULL) {};
|
||||
|
||||
/** Allows implicit cast from real pointer */
|
||||
Pointer(ValueType* v) : interface(new Memory(v)) {}
|
||||
|
||||
// Assignment
|
||||
inline Pointer& operator=(const Pointer& r) {
|
||||
delete interface;
|
||||
if (r.interface != NULL) {
|
||||
interface = r.interface->clone();
|
||||
} else {
|
||||
interface = NULL;
|
||||
}
|
||||
return this[0];
|
||||
}
|
||||
|
||||
Pointer(const Pointer& p) : interface(NULL) {
|
||||
this[0] = p;
|
||||
}
|
||||
|
||||
template<class Class>
|
||||
Pointer(const ReferenceCountedPointer<Class>& object,
|
||||
ValueType (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(ValueType)) :
|
||||
interface(new RefAccessor<Class, ValueType (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(const ReferenceCountedPointer<Class>& object,
|
||||
const ValueType& (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(ValueType)) :
|
||||
interface(new RefAccessor<Class, const ValueType& (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(const ReferenceCountedPointer<Class>& object,
|
||||
ValueType (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(const ValueType&)) :
|
||||
interface(new RefAccessor<Class, ValueType (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(const ReferenceCountedPointer<Class>& object,
|
||||
const ValueType& (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(const ValueType&)) :
|
||||
interface(new RefAccessor<Class, const ValueType& (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(Class* object,
|
||||
const ValueType& (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(const ValueType&)) :
|
||||
interface(new Accessor<Class, const ValueType& (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(Class* object,
|
||||
ValueType (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(const ValueType&)) :
|
||||
interface(new Accessor<Class, ValueType (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(Class* object,
|
||||
const ValueType& (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(ValueType)) :
|
||||
interface(new Accessor<Class, const ValueType& (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
|
||||
|
||||
template<class Class>
|
||||
Pointer(Class* object,
|
||||
ValueType (Class::*getMethod)() const,
|
||||
void (Class::*setMethod)(ValueType)) :
|
||||
interface(new Accessor<Class, ValueType (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
|
||||
|
||||
~Pointer() {
|
||||
delete interface;
|
||||
}
|
||||
|
||||
inline const ValueType getValue() const {
|
||||
debugAssert(interface != NULL);
|
||||
return interface->get();
|
||||
}
|
||||
|
||||
inline void setValue(const ValueType& v) {
|
||||
debugAssert(interface != NULL);
|
||||
interface->set(v);
|
||||
}
|
||||
|
||||
class IndirectValue {
|
||||
private:
|
||||
|
||||
friend class Pointer;
|
||||
Pointer* pointer;
|
||||
IndirectValue(Pointer* p) : pointer(p) {}
|
||||
|
||||
public:
|
||||
|
||||
void operator=(const ValueType& v) {
|
||||
pointer->setValue(v);
|
||||
}
|
||||
|
||||
operator ValueType() const {
|
||||
return pointer->getValue();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
inline IndirectValue operator*() {
|
||||
return IndirectValue(this);
|
||||
}
|
||||
|
||||
inline const ValueType operator*() const {
|
||||
return getValue();
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,7 @@
|
||||
#ifndef G3D_POSITIONTRAIT_H
|
||||
#define G3D_POSITIONTRAIT_H
|
||||
|
||||
template<typename Value>
|
||||
struct PositionTrait{};
|
||||
|
||||
#endif
|
||||
+725
@@ -0,0 +1,725 @@
|
||||
/**
|
||||
@file Quat.h
|
||||
|
||||
Quaternion
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2002-01-23
|
||||
@edited 2006-05-10
|
||||
*/
|
||||
|
||||
#ifndef G3D_QUAT_H
|
||||
#define G3D_QUAT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Matrix3.h"
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Unit quaternions are used in computer graphics to represent
|
||||
rotation about an axis. Any 3x3 rotation matrix can
|
||||
be stored as a quaternion.
|
||||
|
||||
A quaternion represents the sum of a real scalar and
|
||||
an imaginary vector: ix + jy + kz + w. A unit quaternion
|
||||
representing a rotation by A about axis v has the form
|
||||
[sin(A/2)*v, cos(A/2)]. For a unit quaternion, q.conj() == q.inverse()
|
||||
is a rotation by -A about v. -q is the same rotation as q
|
||||
(negate both the axis and angle).
|
||||
|
||||
A non-unit quaterion q represents the same rotation as
|
||||
q.unitize() (Dam98 pg 28).
|
||||
|
||||
Although quaternion-vector operations (eg. Quat + Vector3) are
|
||||
well defined, they are not supported by this class because
|
||||
they typically are bugs when they appear in code.
|
||||
|
||||
Do not subclass.
|
||||
|
||||
<B>BETA API -- subject to change</B>
|
||||
@cite Erik B. Dam, Martin Koch, Martin Lillholm, Quaternions, Interpolation and Animation. Technical Report DIKU-TR-98/5, Department of Computer Science, University of Copenhagen, Denmark. 1998.
|
||||
*/
|
||||
class Quat {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Quat&) const;
|
||||
bool operator>(const Quat&) const;
|
||||
bool operator<=(const Quat&) const;
|
||||
bool operator>=(const Quat&) const;
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
q = [sin(angle / 2) * axis, cos(angle / 2)]
|
||||
|
||||
In Watt & Watt's notation, s = w, v = (x, y, z)
|
||||
In the Real-Time Rendering notation, u = (x, y, z), w = w
|
||||
*/
|
||||
float x, y, z, w;
|
||||
|
||||
/**
|
||||
Initializes to a zero degree rotation.
|
||||
*/
|
||||
inline Quat() : x(0), y(0), z(0), w(1) {}
|
||||
|
||||
Quat(
|
||||
const Matrix3& rot);
|
||||
|
||||
inline Quat(float _x, float _y, float _z, float _w) :
|
||||
x(_x), y(_y), z(_z), w(_w) {}
|
||||
|
||||
/** Defaults to a pure vector quaternion */
|
||||
inline Quat(const Vector3& v, float _w = 0) : x(v.x), y(v.y), z(v.z), w(_w) {
|
||||
}
|
||||
|
||||
/**
|
||||
The real part of the quaternion.
|
||||
*/
|
||||
inline const float& real() const {
|
||||
return w;
|
||||
}
|
||||
|
||||
inline float& real() {
|
||||
return w;
|
||||
}
|
||||
|
||||
/** Note: two quats can represent the Quat::sameRotation and not be equal. */
|
||||
bool fuzzyEq(const Quat& q) {
|
||||
return G3D::fuzzyEq(x, q.x) && G3D::fuzzyEq(y, q.y) && G3D::fuzzyEq(z, q.z) && G3D::fuzzyEq(w, q.w);
|
||||
}
|
||||
|
||||
/** True if these quaternions represent the same rotation (note that every rotation is
|
||||
represented by two values; q and -q).
|
||||
*/
|
||||
bool sameRotation(const Quat& q) {
|
||||
return fuzzyEq(q) || fuzzyEq(-q);
|
||||
}
|
||||
|
||||
inline Quat operator-() const {
|
||||
return Quat(-x, -y, -z, -w);
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the imaginary part (x, y, z)
|
||||
*/
|
||||
inline const Vector3& imag() const {
|
||||
return *(reinterpret_cast<const Vector3*>(this));
|
||||
}
|
||||
|
||||
inline Vector3& imag() {
|
||||
return *(reinterpret_cast<Vector3*>(this));
|
||||
}
|
||||
|
||||
/** q = [sin(angle/2)*axis, cos(angle/2)] */
|
||||
static Quat fromAxisAngleRotation(
|
||||
const Vector3& axis,
|
||||
float angle);
|
||||
|
||||
/** Returns the axis and angle of rotation represented
|
||||
by this quaternion (i.e. q = [sin(angle/2)*axis, cos(angle/2)]) */
|
||||
void toAxisAngleRotation(
|
||||
Vector3& axis,
|
||||
double& angle) const;
|
||||
|
||||
void toAxisAngleRotation(
|
||||
Vector3& axis,
|
||||
float& angle) const {
|
||||
double d;
|
||||
toAxisAngleRotation(axis, d);
|
||||
angle = (float)d;
|
||||
}
|
||||
|
||||
Matrix3 toRotationMatrix() const;
|
||||
|
||||
void toRotationMatrix(
|
||||
Matrix3& rot) const;
|
||||
|
||||
/**
|
||||
Spherical linear interpolation: linear interpolation along the
|
||||
shortest (3D) great-circle route between two quaternions.
|
||||
|
||||
Note: Correct rotations are expected between 0 and PI in the right order.
|
||||
|
||||
@cite Based on Game Physics -- David Eberly pg 538-540
|
||||
@param threshold Critical angle between between rotations at which
|
||||
the algorithm switches to normalized lerp, which is more
|
||||
numerically stable in those situations. 0.0 will always slerp.
|
||||
*/
|
||||
Quat slerp(
|
||||
const Quat& other,
|
||||
float alpha,
|
||||
float threshold = 0.05f) const;
|
||||
|
||||
/** Normalized linear interpolation of quaternion components. */
|
||||
Quat nlerp(const Quat& other, float alpha) const;
|
||||
|
||||
/**
|
||||
Negates the imaginary part.
|
||||
*/
|
||||
inline Quat conj() const {
|
||||
return Quat(-x, -y, -z, w);
|
||||
}
|
||||
|
||||
inline float sum() const {
|
||||
return x + y + z + w;
|
||||
}
|
||||
|
||||
inline float average() const {
|
||||
return sum() / 4.0f;
|
||||
}
|
||||
|
||||
inline Quat operator*(float s) const {
|
||||
return Quat(x * s, y * s, z * s, w * s);
|
||||
}
|
||||
|
||||
inline Quat& operator*=(float s) {
|
||||
x *= s;
|
||||
y *= s;
|
||||
z *= s;
|
||||
w *= s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** @cite Based on Watt & Watt, page 360 */
|
||||
friend Quat operator* (float s, const Quat& q);
|
||||
|
||||
inline Quat operator/(float s) const {
|
||||
return Quat(x / s, y / s, z / s, w / s);
|
||||
}
|
||||
|
||||
inline float dot(const Quat& other) const {
|
||||
return (x * other.x) + (y * other.y) + (z * other.z) + (w * other.w);
|
||||
}
|
||||
|
||||
/** Note that q<SUP>-1</SUP> = q.conj() for a unit quaternion.
|
||||
@cite Dam99 page 13 */
|
||||
inline Quat inverse() const {
|
||||
return conj() / dot(*this);
|
||||
}
|
||||
|
||||
Quat operator-(const Quat& other) const;
|
||||
|
||||
Quat operator+(const Quat& other) const;
|
||||
|
||||
/**
|
||||
Quaternion multiplication (composition of rotations).
|
||||
Note that this does not commute.
|
||||
*/
|
||||
Quat operator*(const Quat& other) const;
|
||||
|
||||
/* (*this) * other.inverse() */
|
||||
Quat operator/(const Quat& other) const {
|
||||
return (*this) * other.inverse();
|
||||
}
|
||||
|
||||
|
||||
/** Is the magnitude nearly 1.0? */
|
||||
inline bool isUnit(float tolerance = 1e-5) const {
|
||||
return abs(dot(*this) - 1.0f) < tolerance;
|
||||
}
|
||||
|
||||
|
||||
inline float magnitude() const {
|
||||
return sqrtf(dot(*this));
|
||||
}
|
||||
|
||||
inline Quat log() const {
|
||||
if ((x == 0) && (y == 0) && (z == 0)) {
|
||||
if (w > 0) {
|
||||
return Quat(0, 0, 0, ::logf(w));
|
||||
} else if (w < 0) {
|
||||
// Log of a negative number. Multivalued, any number of the form
|
||||
// (PI * v, ln(-q.w))
|
||||
return Quat((float)pi(), 0, 0, ::logf(-w));
|
||||
} else {
|
||||
// log of zero!
|
||||
return Quat((float)nan(), (float)nan(), (float)nan(), (float)nan());
|
||||
}
|
||||
} else {
|
||||
// Partly imaginary.
|
||||
float imagLen = sqrtf(x * x + y * y + z * z);
|
||||
float len = sqrtf(imagLen * imagLen + w * w);
|
||||
float theta = atan2f(imagLen, (float)w);
|
||||
float t = theta / imagLen;
|
||||
return Quat(t * x, t * y, t * z, ::logf(len));
|
||||
}
|
||||
}
|
||||
/** log q = [Av, 0] where q = [sin(A) * v, cos(A)].
|
||||
Only for unit quaternions
|
||||
debugAssertM(isUnit(), "Log only defined for unit quaternions");
|
||||
// Solve for A in q = [sin(A)*v, cos(A)]
|
||||
Vector3 u(x, y, z);
|
||||
double len = u.magnitude();
|
||||
|
||||
if (len == 0.0) {
|
||||
return
|
||||
}
|
||||
double A = atan2((double)w, len);
|
||||
Vector3 v = u / len;
|
||||
|
||||
return Quat(v * A, 0);
|
||||
}
|
||||
*/
|
||||
|
||||
/** exp q = [sin(A) * v, cos(A)] where q = [Av, 0].
|
||||
Only defined for pure-vector quaternions */
|
||||
inline Quat exp() const {
|
||||
debugAssertM(w == 0, "exp only defined for vector quaternions");
|
||||
Vector3 u(x, y, z);
|
||||
float A = u.magnitude();
|
||||
Vector3 v = u / A;
|
||||
return Quat(sinf(A) * v, cosf(A));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Raise this quaternion to a power. For a rotation, this is
|
||||
the effect of rotating x times as much as the original
|
||||
quaterion.
|
||||
|
||||
Note that q.pow(a).pow(b) == q.pow(a + b)
|
||||
@cite Dam98 pg 21
|
||||
*/
|
||||
inline Quat pow(float x) const {
|
||||
return (log() * x).exp();
|
||||
}
|
||||
|
||||
inline void unitize() {
|
||||
float mag2 = dot(*this);
|
||||
if (! G3D::fuzzyEq(mag2, 1.0f)) {
|
||||
*this *= rsq(mag2);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a unit quaterion obtained by dividing through by
|
||||
the magnitude.
|
||||
*/
|
||||
inline Quat toUnit() const {
|
||||
Quat x = *this;
|
||||
x.unitize();
|
||||
return x;
|
||||
}
|
||||
|
||||
/**
|
||||
The linear algebra 2-norm, sqrt(q dot q). This matches
|
||||
the value used in Dam's 1998 tech report but differs from the
|
||||
n(q) value used in Eberly's 1999 paper, which is the square of the
|
||||
norm.
|
||||
*/
|
||||
inline float norm() const {
|
||||
return magnitude();
|
||||
}
|
||||
|
||||
// access quaternion as q[0] = q.x, q[1] = q.y, q[2] = q.z, q[3] = q.w
|
||||
//
|
||||
// WARNING. These member functions rely on
|
||||
// (1) Quat not having virtual functions
|
||||
// (2) the data packed in a 4*sizeof(float) memory block
|
||||
const float& operator[] (int i) const;
|
||||
float& operator[] (int i);
|
||||
|
||||
/** Generate uniform random unit quaternion (i.e. random "direction")
|
||||
@cite From "Uniform Random Rotations", Ken Shoemake, Graphics Gems III.
|
||||
*/
|
||||
static Quat unitRandom();
|
||||
|
||||
void deserialize(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
|
||||
// 2-char swizzles
|
||||
|
||||
Vector2 xx() const;
|
||||
Vector2 yx() const;
|
||||
Vector2 zx() const;
|
||||
Vector2 wx() const;
|
||||
Vector2 xy() const;
|
||||
Vector2 yy() const;
|
||||
Vector2 zy() const;
|
||||
Vector2 wy() const;
|
||||
Vector2 xz() const;
|
||||
Vector2 yz() const;
|
||||
Vector2 zz() const;
|
||||
Vector2 wz() const;
|
||||
Vector2 xw() const;
|
||||
Vector2 yw() const;
|
||||
Vector2 zw() const;
|
||||
Vector2 ww() const;
|
||||
|
||||
// 3-char swizzles
|
||||
|
||||
Vector3 xxx() const;
|
||||
Vector3 yxx() const;
|
||||
Vector3 zxx() const;
|
||||
Vector3 wxx() const;
|
||||
Vector3 xyx() const;
|
||||
Vector3 yyx() const;
|
||||
Vector3 zyx() const;
|
||||
Vector3 wyx() const;
|
||||
Vector3 xzx() const;
|
||||
Vector3 yzx() const;
|
||||
Vector3 zzx() const;
|
||||
Vector3 wzx() const;
|
||||
Vector3 xwx() const;
|
||||
Vector3 ywx() const;
|
||||
Vector3 zwx() const;
|
||||
Vector3 wwx() const;
|
||||
Vector3 xxy() const;
|
||||
Vector3 yxy() const;
|
||||
Vector3 zxy() const;
|
||||
Vector3 wxy() const;
|
||||
Vector3 xyy() const;
|
||||
Vector3 yyy() const;
|
||||
Vector3 zyy() const;
|
||||
Vector3 wyy() const;
|
||||
Vector3 xzy() const;
|
||||
Vector3 yzy() const;
|
||||
Vector3 zzy() const;
|
||||
Vector3 wzy() const;
|
||||
Vector3 xwy() const;
|
||||
Vector3 ywy() const;
|
||||
Vector3 zwy() const;
|
||||
Vector3 wwy() const;
|
||||
Vector3 xxz() const;
|
||||
Vector3 yxz() const;
|
||||
Vector3 zxz() const;
|
||||
Vector3 wxz() const;
|
||||
Vector3 xyz() const;
|
||||
Vector3 yyz() const;
|
||||
Vector3 zyz() const;
|
||||
Vector3 wyz() const;
|
||||
Vector3 xzz() const;
|
||||
Vector3 yzz() const;
|
||||
Vector3 zzz() const;
|
||||
Vector3 wzz() const;
|
||||
Vector3 xwz() const;
|
||||
Vector3 ywz() const;
|
||||
Vector3 zwz() const;
|
||||
Vector3 wwz() const;
|
||||
Vector3 xxw() const;
|
||||
Vector3 yxw() const;
|
||||
Vector3 zxw() const;
|
||||
Vector3 wxw() const;
|
||||
Vector3 xyw() const;
|
||||
Vector3 yyw() const;
|
||||
Vector3 zyw() const;
|
||||
Vector3 wyw() const;
|
||||
Vector3 xzw() const;
|
||||
Vector3 yzw() const;
|
||||
Vector3 zzw() const;
|
||||
Vector3 wzw() const;
|
||||
Vector3 xww() const;
|
||||
Vector3 yww() const;
|
||||
Vector3 zww() const;
|
||||
Vector3 www() const;
|
||||
|
||||
// 4-char swizzles
|
||||
|
||||
Vector4 xxxx() const;
|
||||
Vector4 yxxx() const;
|
||||
Vector4 zxxx() const;
|
||||
Vector4 wxxx() const;
|
||||
Vector4 xyxx() const;
|
||||
Vector4 yyxx() const;
|
||||
Vector4 zyxx() const;
|
||||
Vector4 wyxx() const;
|
||||
Vector4 xzxx() const;
|
||||
Vector4 yzxx() const;
|
||||
Vector4 zzxx() const;
|
||||
Vector4 wzxx() const;
|
||||
Vector4 xwxx() const;
|
||||
Vector4 ywxx() const;
|
||||
Vector4 zwxx() const;
|
||||
Vector4 wwxx() const;
|
||||
Vector4 xxyx() const;
|
||||
Vector4 yxyx() const;
|
||||
Vector4 zxyx() const;
|
||||
Vector4 wxyx() const;
|
||||
Vector4 xyyx() const;
|
||||
Vector4 yyyx() const;
|
||||
Vector4 zyyx() const;
|
||||
Vector4 wyyx() const;
|
||||
Vector4 xzyx() const;
|
||||
Vector4 yzyx() const;
|
||||
Vector4 zzyx() const;
|
||||
Vector4 wzyx() const;
|
||||
Vector4 xwyx() const;
|
||||
Vector4 ywyx() const;
|
||||
Vector4 zwyx() const;
|
||||
Vector4 wwyx() const;
|
||||
Vector4 xxzx() const;
|
||||
Vector4 yxzx() const;
|
||||
Vector4 zxzx() const;
|
||||
Vector4 wxzx() const;
|
||||
Vector4 xyzx() const;
|
||||
Vector4 yyzx() const;
|
||||
Vector4 zyzx() const;
|
||||
Vector4 wyzx() const;
|
||||
Vector4 xzzx() const;
|
||||
Vector4 yzzx() const;
|
||||
Vector4 zzzx() const;
|
||||
Vector4 wzzx() const;
|
||||
Vector4 xwzx() const;
|
||||
Vector4 ywzx() const;
|
||||
Vector4 zwzx() const;
|
||||
Vector4 wwzx() const;
|
||||
Vector4 xxwx() const;
|
||||
Vector4 yxwx() const;
|
||||
Vector4 zxwx() const;
|
||||
Vector4 wxwx() const;
|
||||
Vector4 xywx() const;
|
||||
Vector4 yywx() const;
|
||||
Vector4 zywx() const;
|
||||
Vector4 wywx() const;
|
||||
Vector4 xzwx() const;
|
||||
Vector4 yzwx() const;
|
||||
Vector4 zzwx() const;
|
||||
Vector4 wzwx() const;
|
||||
Vector4 xwwx() const;
|
||||
Vector4 ywwx() const;
|
||||
Vector4 zwwx() const;
|
||||
Vector4 wwwx() const;
|
||||
Vector4 xxxy() const;
|
||||
Vector4 yxxy() const;
|
||||
Vector4 zxxy() const;
|
||||
Vector4 wxxy() const;
|
||||
Vector4 xyxy() const;
|
||||
Vector4 yyxy() const;
|
||||
Vector4 zyxy() const;
|
||||
Vector4 wyxy() const;
|
||||
Vector4 xzxy() const;
|
||||
Vector4 yzxy() const;
|
||||
Vector4 zzxy() const;
|
||||
Vector4 wzxy() const;
|
||||
Vector4 xwxy() const;
|
||||
Vector4 ywxy() const;
|
||||
Vector4 zwxy() const;
|
||||
Vector4 wwxy() const;
|
||||
Vector4 xxyy() const;
|
||||
Vector4 yxyy() const;
|
||||
Vector4 zxyy() const;
|
||||
Vector4 wxyy() const;
|
||||
Vector4 xyyy() const;
|
||||
Vector4 yyyy() const;
|
||||
Vector4 zyyy() const;
|
||||
Vector4 wyyy() const;
|
||||
Vector4 xzyy() const;
|
||||
Vector4 yzyy() const;
|
||||
Vector4 zzyy() const;
|
||||
Vector4 wzyy() const;
|
||||
Vector4 xwyy() const;
|
||||
Vector4 ywyy() const;
|
||||
Vector4 zwyy() const;
|
||||
Vector4 wwyy() const;
|
||||
Vector4 xxzy() const;
|
||||
Vector4 yxzy() const;
|
||||
Vector4 zxzy() const;
|
||||
Vector4 wxzy() const;
|
||||
Vector4 xyzy() const;
|
||||
Vector4 yyzy() const;
|
||||
Vector4 zyzy() const;
|
||||
Vector4 wyzy() const;
|
||||
Vector4 xzzy() const;
|
||||
Vector4 yzzy() const;
|
||||
Vector4 zzzy() const;
|
||||
Vector4 wzzy() const;
|
||||
Vector4 xwzy() const;
|
||||
Vector4 ywzy() const;
|
||||
Vector4 zwzy() const;
|
||||
Vector4 wwzy() const;
|
||||
Vector4 xxwy() const;
|
||||
Vector4 yxwy() const;
|
||||
Vector4 zxwy() const;
|
||||
Vector4 wxwy() const;
|
||||
Vector4 xywy() const;
|
||||
Vector4 yywy() const;
|
||||
Vector4 zywy() const;
|
||||
Vector4 wywy() const;
|
||||
Vector4 xzwy() const;
|
||||
Vector4 yzwy() const;
|
||||
Vector4 zzwy() const;
|
||||
Vector4 wzwy() const;
|
||||
Vector4 xwwy() const;
|
||||
Vector4 ywwy() const;
|
||||
Vector4 zwwy() const;
|
||||
Vector4 wwwy() const;
|
||||
Vector4 xxxz() const;
|
||||
Vector4 yxxz() const;
|
||||
Vector4 zxxz() const;
|
||||
Vector4 wxxz() const;
|
||||
Vector4 xyxz() const;
|
||||
Vector4 yyxz() const;
|
||||
Vector4 zyxz() const;
|
||||
Vector4 wyxz() const;
|
||||
Vector4 xzxz() const;
|
||||
Vector4 yzxz() const;
|
||||
Vector4 zzxz() const;
|
||||
Vector4 wzxz() const;
|
||||
Vector4 xwxz() const;
|
||||
Vector4 ywxz() const;
|
||||
Vector4 zwxz() const;
|
||||
Vector4 wwxz() const;
|
||||
Vector4 xxyz() const;
|
||||
Vector4 yxyz() const;
|
||||
Vector4 zxyz() const;
|
||||
Vector4 wxyz() const;
|
||||
Vector4 xyyz() const;
|
||||
Vector4 yyyz() const;
|
||||
Vector4 zyyz() const;
|
||||
Vector4 wyyz() const;
|
||||
Vector4 xzyz() const;
|
||||
Vector4 yzyz() const;
|
||||
Vector4 zzyz() const;
|
||||
Vector4 wzyz() const;
|
||||
Vector4 xwyz() const;
|
||||
Vector4 ywyz() const;
|
||||
Vector4 zwyz() const;
|
||||
Vector4 wwyz() const;
|
||||
Vector4 xxzz() const;
|
||||
Vector4 yxzz() const;
|
||||
Vector4 zxzz() const;
|
||||
Vector4 wxzz() const;
|
||||
Vector4 xyzz() const;
|
||||
Vector4 yyzz() const;
|
||||
Vector4 zyzz() const;
|
||||
Vector4 wyzz() const;
|
||||
Vector4 xzzz() const;
|
||||
Vector4 yzzz() const;
|
||||
Vector4 zzzz() const;
|
||||
Vector4 wzzz() const;
|
||||
Vector4 xwzz() const;
|
||||
Vector4 ywzz() const;
|
||||
Vector4 zwzz() const;
|
||||
Vector4 wwzz() const;
|
||||
Vector4 xxwz() const;
|
||||
Vector4 yxwz() const;
|
||||
Vector4 zxwz() const;
|
||||
Vector4 wxwz() const;
|
||||
Vector4 xywz() const;
|
||||
Vector4 yywz() const;
|
||||
Vector4 zywz() const;
|
||||
Vector4 wywz() const;
|
||||
Vector4 xzwz() const;
|
||||
Vector4 yzwz() const;
|
||||
Vector4 zzwz() const;
|
||||
Vector4 wzwz() const;
|
||||
Vector4 xwwz() const;
|
||||
Vector4 ywwz() const;
|
||||
Vector4 zwwz() const;
|
||||
Vector4 wwwz() const;
|
||||
Vector4 xxxw() const;
|
||||
Vector4 yxxw() const;
|
||||
Vector4 zxxw() const;
|
||||
Vector4 wxxw() const;
|
||||
Vector4 xyxw() const;
|
||||
Vector4 yyxw() const;
|
||||
Vector4 zyxw() const;
|
||||
Vector4 wyxw() const;
|
||||
Vector4 xzxw() const;
|
||||
Vector4 yzxw() const;
|
||||
Vector4 zzxw() const;
|
||||
Vector4 wzxw() const;
|
||||
Vector4 xwxw() const;
|
||||
Vector4 ywxw() const;
|
||||
Vector4 zwxw() const;
|
||||
Vector4 wwxw() const;
|
||||
Vector4 xxyw() const;
|
||||
Vector4 yxyw() const;
|
||||
Vector4 zxyw() const;
|
||||
Vector4 wxyw() const;
|
||||
Vector4 xyyw() const;
|
||||
Vector4 yyyw() const;
|
||||
Vector4 zyyw() const;
|
||||
Vector4 wyyw() const;
|
||||
Vector4 xzyw() const;
|
||||
Vector4 yzyw() const;
|
||||
Vector4 zzyw() const;
|
||||
Vector4 wzyw() const;
|
||||
Vector4 xwyw() const;
|
||||
Vector4 ywyw() const;
|
||||
Vector4 zwyw() const;
|
||||
Vector4 wwyw() const;
|
||||
Vector4 xxzw() const;
|
||||
Vector4 yxzw() const;
|
||||
Vector4 zxzw() const;
|
||||
Vector4 wxzw() const;
|
||||
Vector4 xyzw() const;
|
||||
Vector4 yyzw() const;
|
||||
Vector4 zyzw() const;
|
||||
Vector4 wyzw() const;
|
||||
Vector4 xzzw() const;
|
||||
Vector4 yzzw() const;
|
||||
Vector4 zzzw() const;
|
||||
Vector4 wzzw() const;
|
||||
Vector4 xwzw() const;
|
||||
Vector4 ywzw() const;
|
||||
Vector4 zwzw() const;
|
||||
Vector4 wwzw() const;
|
||||
Vector4 xxww() const;
|
||||
Vector4 yxww() const;
|
||||
Vector4 zxww() const;
|
||||
Vector4 wxww() const;
|
||||
Vector4 xyww() const;
|
||||
Vector4 yyww() const;
|
||||
Vector4 zyww() const;
|
||||
Vector4 wyww() const;
|
||||
Vector4 xzww() const;
|
||||
Vector4 yzww() const;
|
||||
Vector4 zzww() const;
|
||||
Vector4 wzww() const;
|
||||
Vector4 xwww() const;
|
||||
Vector4 ywww() const;
|
||||
Vector4 zwww() const;
|
||||
Vector4 wwww() const;
|
||||
};
|
||||
|
||||
inline Quat exp(const Quat& q) {
|
||||
return q.exp();
|
||||
}
|
||||
|
||||
inline Quat log(const Quat& q) {
|
||||
return q.log();
|
||||
}
|
||||
|
||||
inline G3D::Quat operator*(double s, const G3D::Quat& q) {
|
||||
return q * (float)s;
|
||||
}
|
||||
|
||||
inline G3D::Quat operator*(float s, const G3D::Quat& q) {
|
||||
return q * s;
|
||||
}
|
||||
|
||||
inline float& Quat::operator[] (int i) {
|
||||
debugAssert(i >= 0);
|
||||
debugAssert(i < 4);
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
inline const float& Quat::operator[] (int i) const {
|
||||
debugAssert(i >= 0);
|
||||
debugAssert(i < 4);
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
inline Quat Quat::operator-(const Quat& other) const {
|
||||
return Quat(x - other.x, y - other.y, z - other.z, w - other.w);
|
||||
}
|
||||
|
||||
inline Quat Quat::operator+(const Quat& other) const {
|
||||
return Quat(x + other.x, y + other.y, z + other.z, w + other.w);
|
||||
}
|
||||
|
||||
} // Namespace G3D
|
||||
|
||||
// Outside the namespace to avoid overloading confusion for C++
|
||||
inline G3D::Quat pow(const G3D::Quat& q, double x) {
|
||||
return q.pow((float)x);
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
+355
@@ -0,0 +1,355 @@
|
||||
/**
|
||||
@file Queue.h
|
||||
|
||||
@maintainer Morgan McGuire, graphics3d.com
|
||||
|
||||
@created 2002-07-09
|
||||
@edited 2005-08-20
|
||||
*/
|
||||
|
||||
#ifndef G3D_QUEUE_H
|
||||
#define G3D_QUEUE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/System.h"
|
||||
#include "G3D/debug.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Locate the indices of the break between of the two
|
||||
sections of the circular queue. These are used to
|
||||
construct two for loops that iterate over the whole
|
||||
sequence without using the modulo operator.
|
||||
|
||||
[0 ... secondEnd) [head .... firstEnd)
|
||||
*/
|
||||
#define FIND_ENDS \
|
||||
int firstEnd = head + num;\
|
||||
int secondEnd = 0;\
|
||||
if (firstEnd > numAllocated) {\
|
||||
secondEnd = firstEnd - numAllocated;\
|
||||
firstEnd = numAllocated;\
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Dynamic queue that uses a circular buffer for performance.
|
||||
|
||||
Faster than std::deque for objects with constructors.
|
||||
*/
|
||||
template <class T>
|
||||
class Queue {
|
||||
private:
|
||||
//
|
||||
// |<---- num ---->|
|
||||
// [ | | | | | | | | | | | | | ]
|
||||
// ^
|
||||
// |
|
||||
// head
|
||||
//
|
||||
//
|
||||
|
||||
/**
|
||||
Only num elements are initialized.
|
||||
*/
|
||||
T* data;
|
||||
|
||||
/**
|
||||
Index of the next element to be dequeue-d in data.
|
||||
*/
|
||||
int head;
|
||||
|
||||
/**
|
||||
Number of elements (including head) that are visible and initialized.
|
||||
*/
|
||||
int num;
|
||||
|
||||
/**
|
||||
Size of data array in elements.
|
||||
*/
|
||||
int numAllocated;
|
||||
|
||||
/** If a clear was needed, assumes it already occured */
|
||||
void _copy(const Queue& other) {
|
||||
debugAssert(data == NULL);
|
||||
data = (T*)System::malloc(sizeof(T) * other.numAllocated);
|
||||
debugAssert(data);
|
||||
head = other.head;
|
||||
num = other.num;
|
||||
numAllocated = other.numAllocated;
|
||||
|
||||
FIND_ENDS;
|
||||
|
||||
for (int i = head; i < firstEnd; ++i) {
|
||||
new (data + i)T(other.data[i]);
|
||||
}
|
||||
|
||||
for (int i = 0; i < secondEnd; ++i) {
|
||||
new (data + i)T(other.data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Computes a data array index from a queue position. The queue position
|
||||
may be negative.
|
||||
*/
|
||||
inline int index(int i) const {
|
||||
return (head + i + numAllocated) % numAllocated;
|
||||
}
|
||||
|
||||
/**
|
||||
Allocates newSize elements and repacks the array.
|
||||
*/
|
||||
void repackAndRealloc(int newSize) {
|
||||
// TODO: shrink queue
|
||||
T* old = data;
|
||||
data = (T*)System::malloc(newSize * sizeof(T));
|
||||
debugAssert(data != NULL);
|
||||
|
||||
FIND_ENDS;
|
||||
|
||||
int j = 0;
|
||||
for (int i = head; i < firstEnd; ++i, ++j) {
|
||||
new (data + j)T(old[i]);
|
||||
(old + i)->~T();
|
||||
}
|
||||
|
||||
for (int i = 0; i < secondEnd; ++i, ++j) {
|
||||
new (data + j)T(old[i]);
|
||||
(old + i)->~T();
|
||||
}
|
||||
|
||||
head = 0;
|
||||
System::free(old);
|
||||
numAllocated = newSize;
|
||||
}
|
||||
|
||||
/**
|
||||
Ensure that there is at least one element between
|
||||
the tail and head, wrapping around in the circular
|
||||
buffer.
|
||||
*/
|
||||
inline void reserveSpace() {
|
||||
if (num == numAllocated) {
|
||||
repackAndRealloc(numAllocated * 3 + 20);
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
Queue() :
|
||||
data(NULL),
|
||||
head(0),
|
||||
num(0),
|
||||
numAllocated(0) {
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Copy constructor
|
||||
*/
|
||||
Queue(const Queue& other) : data(NULL) {
|
||||
_copy(other);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Destructor does not delete() the objects if T is a pointer type
|
||||
(e.g. T = int*) instead, it deletes the pointers themselves and
|
||||
leaves the objects. Call deleteAll if you want to dealocate
|
||||
the objects referenced.
|
||||
*/
|
||||
virtual ~Queue() {
|
||||
clear();
|
||||
}
|
||||
|
||||
/**
|
||||
Insert a new element into the front of the queue
|
||||
(a traditional queue only uses pushBack).
|
||||
*/
|
||||
inline void pushFront(const T& e) {
|
||||
reserveSpace();
|
||||
|
||||
// Get the index of head-1
|
||||
int i = index(-1);
|
||||
|
||||
// Call the constructor on the newly exposed element.
|
||||
new (data + i)T(e);
|
||||
|
||||
// Reassign the head to point to this index
|
||||
head = i;
|
||||
++num;
|
||||
}
|
||||
|
||||
/**
|
||||
Insert a new element at the end of the queue.
|
||||
*/
|
||||
inline void pushBack(const T& e) {
|
||||
reserveSpace();
|
||||
|
||||
// Get the index of 1+tail
|
||||
int i = index(num);
|
||||
|
||||
// Initialize that element
|
||||
new (data + i)T(e);
|
||||
++num;
|
||||
}
|
||||
|
||||
/**
|
||||
pushBack
|
||||
*/
|
||||
inline void enqueue(const T& e) {
|
||||
pushBack(e);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Remove the last element from the queue. The queue will never
|
||||
shrink in size. (A typical queue only uses popFront).
|
||||
*/
|
||||
inline T popBack() {
|
||||
int tail = index(num - 1);
|
||||
T result(data[tail]);
|
||||
|
||||
// Call the destructor
|
||||
(data + tail)->~T();
|
||||
--num;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
Remove the next element from the head of the queue. The queue will never
|
||||
shrink in size. */
|
||||
inline T popFront() {
|
||||
T result(data[head]);
|
||||
// Call the destructor
|
||||
(data + head)->~T();
|
||||
head = (head + 1) % numAllocated;
|
||||
--num;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
popFront
|
||||
*/
|
||||
inline T dequeue() {
|
||||
return popFront();
|
||||
}
|
||||
|
||||
/**
|
||||
Removes all elements (invoking their destructors).
|
||||
|
||||
@param freeStorage If false, the underlying array is not deallocated
|
||||
(allowing fast push in the future), however, the size of the Queue
|
||||
is reported as zero.
|
||||
|
||||
*/
|
||||
void clear(bool freeStorage = true) {
|
||||
|
||||
FIND_ENDS;
|
||||
|
||||
// Invoke the destructors on the elements
|
||||
int i;
|
||||
for (i = head; i < firstEnd; ++i) {
|
||||
(data + i)->~T();
|
||||
}
|
||||
|
||||
for (i = 0; i < secondEnd; ++i) {
|
||||
(data + i)->~T();
|
||||
}
|
||||
|
||||
num = 0;
|
||||
head = 0;
|
||||
if (freeStorage) {
|
||||
numAllocated = 0;
|
||||
System::free(data);
|
||||
data = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/** Clear without freeing the underlying array. */
|
||||
void fastClear() {
|
||||
clear(false);
|
||||
}
|
||||
|
||||
/**
|
||||
Assignment operator.
|
||||
*/
|
||||
Queue& operator=(const Queue& other) {
|
||||
clear();
|
||||
_copy(other);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
Number of elements in the queue.
|
||||
*/
|
||||
inline int size() const {
|
||||
return num;
|
||||
}
|
||||
|
||||
/**
|
||||
Number of elements in the queue.
|
||||
*/
|
||||
inline int length() const {
|
||||
return size();
|
||||
}
|
||||
|
||||
/**
|
||||
Performs bounds checks in debug mode
|
||||
*/
|
||||
inline T& operator[](int n) {
|
||||
debugAssert((n >= 0) && (n < num));
|
||||
return data[index(n)];
|
||||
}
|
||||
|
||||
/**
|
||||
Performs bounds checks in debug mode
|
||||
*/
|
||||
inline const T& operator[](int n) const {
|
||||
debugAssert((n >= 0) && (n < num));
|
||||
return data[index(n)];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Returns true if the given element is in the queue.
|
||||
*/
|
||||
bool contains(const T& e) const {
|
||||
for (int i = 0; i < size(); ++i) {
|
||||
if ((*this)[i] == e) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
Calls delete on all objects[0...size-1]
|
||||
and sets the queue size to zero.
|
||||
*/
|
||||
void deleteAll() {
|
||||
FIND_ENDS;
|
||||
|
||||
int i;
|
||||
for (i = 0; i < secondEnd; ++i) {
|
||||
delete data[i];
|
||||
}
|
||||
|
||||
for (i = head; i < firstEnd; ++i) {
|
||||
delete data[i];
|
||||
}
|
||||
clear();
|
||||
}
|
||||
};
|
||||
|
||||
#undef FIND_ENDS
|
||||
|
||||
}; // namespace
|
||||
|
||||
#endif
|
||||
+329
@@ -0,0 +1,329 @@
|
||||
/**
|
||||
@file Ray.h
|
||||
|
||||
Ray class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2002-07-12
|
||||
@edited 2006-02-21
|
||||
*/
|
||||
|
||||
#ifndef G3D_RAY_H
|
||||
#define G3D_RAY_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Triangle.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A 3D Ray.
|
||||
*/
|
||||
class Ray {
|
||||
private:
|
||||
Ray(const Vector3& origin, const Vector3& direction) {
|
||||
this->origin = origin;
|
||||
this->direction = direction;
|
||||
}
|
||||
|
||||
public:
|
||||
Vector3 origin;
|
||||
|
||||
/**
|
||||
Not unit length
|
||||
*/
|
||||
Vector3 direction;
|
||||
|
||||
Ray() : origin(Vector3::zero()), direction(Vector3::zero()) {}
|
||||
|
||||
Ray(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
/**
|
||||
Creates a Ray from a origin and a (nonzero) direction.
|
||||
*/
|
||||
static Ray fromOriginAndDirection(const Vector3& point, const Vector3& direction) {
|
||||
return Ray(point, direction);
|
||||
}
|
||||
|
||||
Ray unit() const {
|
||||
return Ray(origin, direction.unit());
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the closest point on the Ray to point.
|
||||
*/
|
||||
Vector3 closestPoint(const Vector3& point) const {
|
||||
float t = direction.dot(point - this->origin);
|
||||
if (t < 0) {
|
||||
return this->origin;
|
||||
} else {
|
||||
return this->origin + direction * t;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the closest distance between point and the Ray
|
||||
*/
|
||||
float distance(const Vector3& point) const {
|
||||
return (closestPoint(point) - point).magnitude();
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the point where the Ray and plane intersect. If there
|
||||
is no intersection, returns a point at infinity.
|
||||
|
||||
Planes are considered one-sided, so the ray will not intersect
|
||||
a plane where the normal faces in the traveling direction.
|
||||
*/
|
||||
Vector3 intersection(const class Plane& plane) const;
|
||||
|
||||
/**
|
||||
Returns the distance until intersection with the (solid) sphere.
|
||||
Will be 0 if inside the sphere, inf if there is no intersection.
|
||||
|
||||
The ray direction is <B>not</B> normalized. If the ray direction
|
||||
has unit length, the distance from the origin to intersection
|
||||
is equal to the time. If the direction does not have unit length,
|
||||
the distance = time * direction.length().
|
||||
|
||||
See also the G3D::CollisionDetection "movingPoint" methods,
|
||||
which give more information about the intersection.
|
||||
*/
|
||||
float intersectionTime(const class Sphere& sphere) const;
|
||||
|
||||
float intersectionTime(const class Plane& plane) const;
|
||||
|
||||
float intersectionTime(const class Box& box) const;
|
||||
|
||||
float intersectionTime(const class AABox& box) const;
|
||||
|
||||
/**
|
||||
The three extra arguments are the weights of vertices 0, 1, and 2
|
||||
at the intersection point; they are useful for texture mapping
|
||||
and interpolated normals.
|
||||
*/
|
||||
float intersectionTime(
|
||||
const Vector3& v0, const Vector3& v1, const Vector3& v2,
|
||||
const Vector3& edge01, const Vector3& edge02,
|
||||
double& w0, double& w1, double& w2) const;
|
||||
|
||||
/**
|
||||
Ray-triangle intersection for a 1-sided triangle. Fastest version.
|
||||
@cite http://www.acm.org/jgt/papers/MollerTrumbore97/
|
||||
http://www.graphics.cornell.edu/pubs/1997/MT97.html
|
||||
*/
|
||||
inline float intersectionTime(
|
||||
const Vector3& vert0,
|
||||
const Vector3& vert1,
|
||||
const Vector3& vert2,
|
||||
const Vector3& edge01,
|
||||
const Vector3& edge02) const;
|
||||
|
||||
|
||||
inline float intersectionTime(
|
||||
const Vector3& vert0,
|
||||
const Vector3& vert1,
|
||||
const Vector3& vert2) const {
|
||||
|
||||
return intersectionTime(vert0, vert1, vert2, vert1 - vert0, vert2 - vert0);
|
||||
}
|
||||
|
||||
|
||||
inline float intersectionTime(
|
||||
const Vector3& vert0,
|
||||
const Vector3& vert1,
|
||||
const Vector3& vert2,
|
||||
double& w0,
|
||||
double& w1,
|
||||
double& w2) const {
|
||||
|
||||
return intersectionTime(vert0, vert1, vert2, vert1 - vert0, vert2 - vert0, w0, w1, w2);
|
||||
}
|
||||
|
||||
/* One-sided triangle
|
||||
*/
|
||||
inline float intersectionTime(const Triangle& triangle) const {
|
||||
return intersectionTime(
|
||||
triangle.vertex(0), triangle.vertex(1), triangle.vertex(2),
|
||||
triangle.edge01(), triangle.edge02());
|
||||
}
|
||||
|
||||
inline float intersectionTime(
|
||||
const Triangle& triangle,
|
||||
double& w0,
|
||||
double& w1,
|
||||
double& w2) const {
|
||||
return intersectionTime(triangle.vertex(0), triangle.vertex(1), triangle.vertex(2),
|
||||
triangle.edge01(), triangle.edge02(), w0, w1, w2);
|
||||
}
|
||||
|
||||
/** Refracts about the normal
|
||||
using G3D::Vector3::refractionDirection
|
||||
and bumps the ray slightly from the newOrigin. */
|
||||
Ray refract(
|
||||
const Vector3& newOrigin,
|
||||
const Vector3& normal,
|
||||
float iInside,
|
||||
float iOutside) const;
|
||||
|
||||
/** Reflects about the normal
|
||||
using G3D::Vector3::reflectionDirection
|
||||
and bumps the ray slightly from
|
||||
the newOrigin. */
|
||||
Ray reflect(
|
||||
const Vector3& newOrigin,
|
||||
const Vector3& normal) const;
|
||||
};
|
||||
|
||||
|
||||
#define EPSILON 0.000001
|
||||
#define CROSS(dest,v1,v2) \
|
||||
dest[0]=v1[1]*v2[2]-v1[2]*v2[1]; \
|
||||
dest[1]=v1[2]*v2[0]-v1[0]*v2[2]; \
|
||||
dest[2]=v1[0]*v2[1]-v1[1]*v2[0];
|
||||
|
||||
#define DOT(v1,v2) (v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2])
|
||||
|
||||
#define SUB(dest,v1,v2) \
|
||||
dest[0]=v1[0]-v2[0]; \
|
||||
dest[1]=v1[1]-v2[1]; \
|
||||
dest[2]=v1[2]-v2[2];
|
||||
|
||||
inline float Ray::intersectionTime(
|
||||
const Vector3& vert0,
|
||||
const Vector3& vert1,
|
||||
const Vector3& vert2,
|
||||
const Vector3& edge1,
|
||||
const Vector3& edge2) const {
|
||||
|
||||
(void)vert1;
|
||||
(void)vert2;
|
||||
|
||||
// Barycenteric coords
|
||||
float u, v;
|
||||
|
||||
float tvec[3], pvec[3], qvec[3];
|
||||
|
||||
// begin calculating determinant - also used to calculate U parameter
|
||||
CROSS(pvec, direction, edge2);
|
||||
|
||||
// if determinant is near zero, ray lies in plane of triangle
|
||||
const float det = DOT(edge1, pvec);
|
||||
|
||||
if (det < EPSILON) {
|
||||
return (float)inf();
|
||||
}
|
||||
|
||||
// calculate distance from vert0 to ray origin
|
||||
SUB(tvec, origin, vert0);
|
||||
|
||||
// calculate U parameter and test bounds
|
||||
u = DOT(tvec, pvec);
|
||||
if ((u < 0.0f) || (u > det)) {
|
||||
// Hit the plane outside the triangle
|
||||
return (float)inf();
|
||||
}
|
||||
|
||||
// prepare to test V parameter
|
||||
CROSS(qvec, tvec, edge1);
|
||||
|
||||
// calculate V parameter and test bounds
|
||||
v = DOT(direction, qvec);
|
||||
if ((v < 0.0f) || (u + v > det)) {
|
||||
// Hit the plane outside the triangle
|
||||
return (float)inf();
|
||||
}
|
||||
|
||||
|
||||
// Case where we don't need correct (u, v):
|
||||
const float t = DOT(edge2, qvec);
|
||||
|
||||
if (t >= 0.0f) {
|
||||
// Note that det must be positive
|
||||
return t / det;
|
||||
} else {
|
||||
// We had to travel backwards in time to intersect
|
||||
return (float)inf();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline float Ray::intersectionTime(
|
||||
const Vector3& vert0,
|
||||
const Vector3& vert1,
|
||||
const Vector3& vert2,
|
||||
const Vector3& edge1,
|
||||
const Vector3& edge2,
|
||||
double& w0,
|
||||
double& w1,
|
||||
double& w2) const {
|
||||
|
||||
(void)vert1;
|
||||
(void)vert2;
|
||||
|
||||
// Barycenteric coords
|
||||
float u, v;
|
||||
|
||||
float tvec[3], pvec[3], qvec[3];
|
||||
|
||||
// begin calculating determinant - also used to calculate U parameter
|
||||
CROSS(pvec, direction, edge2);
|
||||
|
||||
// if determinant is near zero, ray lies in plane of triangle
|
||||
const float det = DOT(edge1, pvec);
|
||||
|
||||
if (det < EPSILON) {
|
||||
return (float)inf();
|
||||
}
|
||||
|
||||
// calculate distance from vert0 to ray origin
|
||||
SUB(tvec, origin, vert0);
|
||||
|
||||
// calculate U parameter and test bounds
|
||||
u = DOT(tvec, pvec);
|
||||
if ((u < 0.0f) || (u > det)) {
|
||||
// Hit the plane outside the triangle
|
||||
return (float)inf();
|
||||
}
|
||||
|
||||
// prepare to test V parameter
|
||||
CROSS(qvec, tvec, edge1);
|
||||
|
||||
// calculate V parameter and test bounds
|
||||
v = DOT(direction, qvec);
|
||||
if ((v < 0.0f) || (u + v > det)) {
|
||||
// Hit the plane outside the triangle
|
||||
return (float)inf();
|
||||
}
|
||||
|
||||
float t = DOT(edge2, qvec);
|
||||
|
||||
if (t >= 0) {
|
||||
const float inv_det = 1.0f / det;
|
||||
t *= inv_det;
|
||||
u *= inv_det;
|
||||
v *= inv_det;
|
||||
|
||||
w0 = (1.0f - u - v);
|
||||
w1 = u;
|
||||
w2 = v;
|
||||
|
||||
return t;
|
||||
} else {
|
||||
// We had to travel backwards in time to intersect
|
||||
return (float)inf();
|
||||
}
|
||||
}
|
||||
|
||||
#undef EPSILON
|
||||
#undef CROSS
|
||||
#undef DOT
|
||||
#undef SUB
|
||||
|
||||
}// namespace
|
||||
|
||||
#endif
|
||||
+391
@@ -0,0 +1,391 @@
|
||||
/**
|
||||
@file Rect2D.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-11-13
|
||||
@created 2008-11-16
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_RECT2D_H
|
||||
#define G3D_RECT2D_H
|
||||
|
||||
// Linux defines this as a macro
|
||||
#ifdef border
|
||||
#undef border
|
||||
#endif
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Vector2.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
If you are using this class for pixel rectangles, keep in mind that the last
|
||||
pixel you can draw to is at x0() + width() - 1.
|
||||
*/
|
||||
class Rect2D {
|
||||
private:
|
||||
Vector2 min, max;
|
||||
|
||||
/**
|
||||
Returns true if the whole polygon is clipped.
|
||||
@param p Value of the point
|
||||
@param axis Index [0 or 1] of the axis to clip along?
|
||||
@param clipGreater Are we clipping greater than or less than the line?
|
||||
@param inPoly Polygon being clipped
|
||||
@param outPoly The clipped polygon
|
||||
*/
|
||||
template<class T>
|
||||
static bool clipSide2D(
|
||||
const float p, bool clipGreater, int axis,
|
||||
const Array<T>& inPoly, Array<T>& outPoly) {
|
||||
|
||||
outPoly.clear();
|
||||
int i0 = -1;
|
||||
|
||||
Vector2 pt1;
|
||||
bool c1 = true;
|
||||
|
||||
float negate = clipGreater ? -1 : 1;
|
||||
|
||||
// Find a point that is not clipped
|
||||
for (i0 = 0; (i0 < inPoly.length()) && c1; ++i0) {
|
||||
pt1 = inPoly[i0];
|
||||
c1 = (negate * pt1[axis]) < (negate * p);
|
||||
}
|
||||
|
||||
// We incremented i0 one time to many
|
||||
--i0;
|
||||
|
||||
if (c1) {
|
||||
// We could not find an unclipped point
|
||||
return true;
|
||||
}
|
||||
|
||||
outPoly.append(pt1);
|
||||
|
||||
// for each point in inPoly,
|
||||
// if the point is outside the side and the previous one was also outside, continue
|
||||
// if the point is outside the side and the previous one was inside, cut the line
|
||||
// if the point is inside the side and the previous one was also inside, append the points
|
||||
// if the point is inside the side and the previous one was outside, cut the line
|
||||
for (int i = 1; i <= inPoly.length(); ++i) {
|
||||
T pt2 = inPoly[(i + i0) % inPoly.length()];
|
||||
bool c2 = (negate * pt2[axis]) < (negate * p);
|
||||
|
||||
if (c1 ^ c2) {
|
||||
|
||||
if (!c1 && c2 && (i > 1)) {
|
||||
// Unclipped to clipped trasition and not the first iteration
|
||||
outPoly.append(pt1);
|
||||
}
|
||||
|
||||
// only one point is clipped, find where the line crosses the clipping plane
|
||||
|
||||
|
||||
float alpha;
|
||||
if (pt2[axis] == pt1[axis]) {
|
||||
alpha = 0;
|
||||
} else {
|
||||
alpha = (p - pt1[axis]) / (pt2[axis] - pt1[axis]);
|
||||
}
|
||||
outPoly.append(pt1.lerp(pt2, alpha));
|
||||
} else if (! (c1 || c2) && (i != 1)) {
|
||||
// neither point is clipped (don't do this the first time
|
||||
// because we appended the first pt before the loop)
|
||||
outPoly.append(pt1);
|
||||
}
|
||||
|
||||
pt1 = pt2;
|
||||
c1 = c2;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
inline Rect2D() : min(0, 0), max(0, 0) {}
|
||||
|
||||
/** Creates a rectangle at 0,0 with the given width and height*/
|
||||
inline Rect2D(const Vector2& wh) : min(0, 0), max(wh.x, wh.y) {}
|
||||
|
||||
/** Computes a rectangle that contains both @a a and @a b.
|
||||
Note that even if @a or @b has zero area, its origin will be included.*/
|
||||
inline Rect2D(const Rect2D& a, const Rect2D& b) {
|
||||
min = a.min.min(b.min);
|
||||
max = a.max.max(b.max);
|
||||
}
|
||||
|
||||
/** @brief Uniformly random point on the interior */
|
||||
inline Vector2 randomPoint() const {
|
||||
return Vector2(uniformRandom(0, max.x - min.x) + min.x,
|
||||
uniformRandom(0, max.y - min.y) + min.y);
|
||||
}
|
||||
|
||||
inline float width() const {
|
||||
return max.x - min.x;
|
||||
}
|
||||
|
||||
inline float height() const {
|
||||
return max.y - min.y;
|
||||
}
|
||||
|
||||
inline float x0() const {
|
||||
return min.x;
|
||||
}
|
||||
|
||||
inline float x1() const {
|
||||
return max.x;
|
||||
}
|
||||
|
||||
inline float y0() const {
|
||||
return min.y;
|
||||
}
|
||||
|
||||
inline float y1() const {
|
||||
return max.y;
|
||||
}
|
||||
|
||||
/** Min, min corner */
|
||||
inline Vector2 x0y0() const {
|
||||
return min;
|
||||
}
|
||||
|
||||
inline Vector2 x1y0() const {
|
||||
return Vector2(max.x, min.y);
|
||||
}
|
||||
|
||||
inline Vector2 x0y1() const {
|
||||
return Vector2(min.x, max.y);
|
||||
}
|
||||
|
||||
/** Max,max corner */
|
||||
inline Vector2 x1y1() const {
|
||||
return max;
|
||||
}
|
||||
|
||||
/** Width and height */
|
||||
inline Vector2 wh() const {
|
||||
return max - min;
|
||||
}
|
||||
|
||||
inline Vector2 center() const {
|
||||
return (max + min) * 0.5;
|
||||
}
|
||||
|
||||
inline static Rect2D xyxy(float x0, float y0, float x1, float y1) {
|
||||
Rect2D r;
|
||||
|
||||
r.min.x = G3D::min(x0, x1);
|
||||
r.min.y = G3D::min(y0, y1);
|
||||
r.max.x = G3D::max(x0, x1);
|
||||
r.max.y = G3D::max(y0, y1);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
Rect2D lerp(const Rect2D& other, float alpha) const {
|
||||
Rect2D out;
|
||||
|
||||
out.min = min.lerp(other.min, alpha);
|
||||
out.max = max.lerp(other.max, alpha);
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
inline static Rect2D xyxy(const Vector2& v0, const Vector2& v1) {
|
||||
Rect2D r;
|
||||
|
||||
r.min = v0.min(v1);
|
||||
r.max = v0.max(v1);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
inline static Rect2D xywh(float x, float y, float w, float h) {
|
||||
return xyxy(x, y, x + w, y + h);
|
||||
}
|
||||
|
||||
inline static Rect2D xywh(const Vector2& v, const Vector2& w) {
|
||||
return xyxy(v.x, v.y, v.x + w.x, v.y + w.y);
|
||||
}
|
||||
|
||||
inline bool contains(const Vector2& v) const {
|
||||
return (v.x >= min.x) && (v.y >= min.y) && (v.x <= max.x) && (v.y <= max.y);
|
||||
}
|
||||
|
||||
inline bool contains(const Rect2D& r) const {
|
||||
return (min.x <= r.min.x) && (min.y <= r.min.y) &&
|
||||
(max.x >= r.max.x) && (max.y >= r.max.y);
|
||||
}
|
||||
|
||||
/** True if there is non-zero area to the intersection between @a this and @a r.
|
||||
Note that two rectangles that are adjacent do not intersect because there is
|
||||
zero area to the overlap, even though one of them "contains" the corners of the other.*/
|
||||
inline bool intersects(const Rect2D& r) const {
|
||||
return (min.x < r.max.x) && (min.y < r.max.y) &&
|
||||
(max.x > r.min.x) && (max.y > r.min.y);
|
||||
}
|
||||
|
||||
/** Like intersection, but counts the adjacent case as touching. */
|
||||
inline bool intersectsOrTouches(const Rect2D& r) const {
|
||||
return (min.x <= r.max.x) && (min.y <= r.max.y) &&
|
||||
(max.x >= r.min.x) && (max.y >= r.min.y);
|
||||
}
|
||||
|
||||
inline Rect2D operator*(float s) const {
|
||||
return xyxy(min.x * s, min.y * s, max.x * s, max.y * s);
|
||||
}
|
||||
|
||||
inline Rect2D operator/(float s) const {
|
||||
return xyxy(min / s, max / s);
|
||||
}
|
||||
|
||||
inline Rect2D operator/(const Vector2& s) const {
|
||||
return xyxy(min / s, max / s);
|
||||
}
|
||||
|
||||
inline Rect2D operator+(const Vector2& v) const {
|
||||
return xyxy(min + v, max + v);
|
||||
}
|
||||
|
||||
inline Rect2D operator-(const Vector2& v) const {
|
||||
return xyxy(min - v, max - v);
|
||||
}
|
||||
|
||||
inline bool operator==(const Rect2D& other) const {
|
||||
return (min == other.min) && (max == other.max);
|
||||
}
|
||||
|
||||
inline bool operator!=(const Rect2D& other) const {
|
||||
return (min != other.min) || (max != other.max);
|
||||
}
|
||||
|
||||
/** Returns the corners in the order: (min,min), (max,min), (max,max), (min,max). */
|
||||
inline Vector2 corner(int i) const {
|
||||
debugAssert(i >= 0 && i < 4);
|
||||
switch (i & 3) {
|
||||
case 0:
|
||||
return Vector2(min.x, min.y);
|
||||
case 1:
|
||||
return Vector2(max.x, min.y);
|
||||
case 2:
|
||||
return Vector2(max.x, max.y);
|
||||
case 3:
|
||||
return Vector2(min.x, max.y);
|
||||
default:
|
||||
// Should never get here
|
||||
return Vector2(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** @deprecated
|
||||
@sa expand() */
|
||||
inline Rect2D border(float delta) const {
|
||||
return Rect2D::xywh(x0() + delta,
|
||||
y0() + delta,
|
||||
width() - 2.0f * delta,
|
||||
height() - 2.0f * delta);
|
||||
}
|
||||
|
||||
/** Returns a new Rect2D that is bigger/smaller by the specified amount
|
||||
(negative is shrink.) */
|
||||
inline Rect2D expand(float delta) const {
|
||||
float newX = x0() - delta;
|
||||
float newY = y0() - delta;
|
||||
float newW = width() + 2.0f * delta;
|
||||
float newH = height() + 2.0f * delta;
|
||||
|
||||
if (newW < 0.0f) {
|
||||
newX = (x0() + width()) / 2.0f;
|
||||
newW = 0.0f;
|
||||
}
|
||||
|
||||
if (newH < 0.0f) {
|
||||
newY = (y0() + height()) / 2.0f;
|
||||
newH = 0.0f;
|
||||
}
|
||||
return Rect2D::xywh(newX, newY, newW, newH);
|
||||
}
|
||||
|
||||
/**
|
||||
Clips so that the rightmost point of the outPoly is at rect.x1 (e.g. a 800x600 window produces
|
||||
rightmost point 799, not 800). The results are suitable for pixel rendering if iRounded.
|
||||
Templated so that it will work for Vector2,3,4 (the z and w components are interpolated linearly).
|
||||
The template parameter must define T.lerp and contain x and y components.
|
||||
|
||||
If the entire polygon is clipped by a single side, the result will be empty.
|
||||
The result might also have zero area but not be empty.
|
||||
*/
|
||||
template<class T>
|
||||
void clip(const Array<T>& inPoly, Array<T>& outPoly) const {
|
||||
|
||||
const bool greaterThan = true;
|
||||
const bool lessThan = false;
|
||||
const int X = 0;
|
||||
const int Y = 1;
|
||||
|
||||
Array<T> temp;
|
||||
|
||||
bool entirelyClipped =
|
||||
clipSide2D(x0(), lessThan, X, inPoly, temp) ||
|
||||
clipSide2D(x1(), greaterThan, X, temp, outPoly) ||
|
||||
clipSide2D(y0(), lessThan, Y, outPoly, temp) ||
|
||||
clipSide2D(y1(), greaterThan, Y, temp, outPoly);
|
||||
|
||||
if (entirelyClipped) {
|
||||
outPoly.clear();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/** Returns the largest, centered Rect2D that can fit inside this
|
||||
while maintaining the aspect ratio of x:y. Convenient for
|
||||
displaying images in odd-shaped windows.
|
||||
*/
|
||||
Rect2D largestCenteredSubRect(float ww, float hh) const {
|
||||
float textureAspect = hh / ww;
|
||||
float viewAspect = height() / width();
|
||||
|
||||
if (viewAspect > textureAspect) {
|
||||
// The view is too tall
|
||||
float h = width() * textureAspect;
|
||||
float y = (height() - h) / 2;
|
||||
return Rect2D::xywh(0, y, width(), h) + corner(0);
|
||||
} else {
|
||||
// The view is too wide
|
||||
float w = height() / textureAspect;
|
||||
float x = (width() - w) / 2;
|
||||
return Rect2D::xywh(x, 0, w, height()) + corner(0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the overlap region between the two rectangles. This may have zero area
|
||||
if they do not intersect. See the two-Rect2D constructor for a way to compute
|
||||
a union-like rectangle.
|
||||
*/
|
||||
Rect2D intersect(const Rect2D& other) const {
|
||||
if (intersects(other)) {
|
||||
return Rect2D::xyxy(min.max(other.min), max.min(other.max));
|
||||
}else{
|
||||
return Rect2D::xywh(0, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
float area() const {
|
||||
return width() * height();
|
||||
}
|
||||
};
|
||||
|
||||
typedef Rect2D AABox2D;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,597 @@
|
||||
/**
|
||||
@file ReferenceCount.h
|
||||
|
||||
Reference Counting Garbage Collector for C++
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@cite Adapted and extended from Justin Miller's "RGC" class that appeared in BYTE magazine.
|
||||
@cite See also http://www.jelovic.com/articles/cpp_without_memory_errors_slides.htm
|
||||
|
||||
@created 2001-10-23
|
||||
@edited 2008-09-25
|
||||
*/
|
||||
|
||||
#ifndef G3D_RGC_H
|
||||
#define G3D_RGC_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/debug.h"
|
||||
#include "G3D/AtomicInt32.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/** Base class for WeakReferenceCountedPointer */
|
||||
class _WeakPtr {
|
||||
public:
|
||||
inline virtual ~_WeakPtr() {}
|
||||
|
||||
protected:
|
||||
friend class ReferenceCountedObject;
|
||||
|
||||
/** Called by ReferenceCountedObject to tell a weak pointer that its underlying object was collected. */
|
||||
virtual void objectCollected() = 0;
|
||||
};
|
||||
|
||||
/** Used internally by ReferenceCountedObject */
|
||||
class _WeakPtrLinkedList {
|
||||
public:
|
||||
_WeakPtr* weakPtr;
|
||||
_WeakPtrLinkedList* next;
|
||||
|
||||
inline _WeakPtrLinkedList() : weakPtr(NULL), next(NULL) {}
|
||||
|
||||
/** Inserts this node into the head of the list that previously had n as its head. */
|
||||
inline _WeakPtrLinkedList(_WeakPtr* p, _WeakPtrLinkedList* n) : weakPtr(p), next(n) {}
|
||||
};
|
||||
|
||||
/**
|
||||
Objects that are reference counted inherit from this. Subclasses
|
||||
<B>must</B> have a public destructor (the default destructor is fine)
|
||||
and <B>publicly</B> inherit ReferenceCountedObject.
|
||||
|
||||
Multiple inheritance from a reference counted object is dangerous-- use
|
||||
at your own risk.
|
||||
|
||||
ReferenceCountedPointer and ReferenceCountedObject are threadsafe.
|
||||
You can create and drop references on multiple threads without
|
||||
violating integrity. WeakReferenceCountedPointer is <i>not</i>
|
||||
threadsafe. Introducing a weak pointer destroys all thread safety,
|
||||
even for strong pointers to the same object (this is inherent in the
|
||||
design of the class; we cannot fix it without slowing down the
|
||||
performance of reference counted objects.)
|
||||
|
||||
<B>Usage Example</B>
|
||||
|
||||
<PRE>
|
||||
|
||||
class Foo : public G3D::ReferenceCountedObject {
|
||||
public:
|
||||
int x;
|
||||
};
|
||||
|
||||
class Bar : public Foo {};
|
||||
|
||||
typedef G3D::ReferenceCountedPointer<Foo> FooRef;
|
||||
typedef G3D::WeakReferenceCountedPointer<Foo> WeakFooRef;
|
||||
typedef G3D::ReferenceCountedPointer<Bar> BarRef;
|
||||
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
|
||||
WeakFooRef x;
|
||||
|
||||
{
|
||||
FooRef a = new Foo();
|
||||
|
||||
// Reference count == 1
|
||||
|
||||
x = a;
|
||||
// Weak references do not increase count
|
||||
|
||||
{
|
||||
FooRef b = a;
|
||||
// Reference count == 2
|
||||
}
|
||||
|
||||
// Reference count == 1
|
||||
}
|
||||
// No more strong references; object automatically deleted.
|
||||
// x is set to NULL automatically.
|
||||
|
||||
// Example of using dynamic cast on reference counted objects
|
||||
BarRef b = new Bar();
|
||||
|
||||
// No cast needed to go down the heirarchy.
|
||||
FooRef f = b;
|
||||
|
||||
// We can't cast the reference object because it is a class.
|
||||
// Instead we must extract the pointer and cast that:
|
||||
b = dynamic_cast<Bar*>(&*f);
|
||||
|
||||
return 0;
|
||||
}
|
||||
</PRE>
|
||||
|
||||
@deprecated To be replaced by boost::shared_ptr in 7.0
|
||||
*/
|
||||
class ReferenceCountedObject {
|
||||
public:
|
||||
|
||||
/**
|
||||
The long name is to keep this from accidentally conflicting with
|
||||
a subclass's variable name. Do not use or explicitly manipulate
|
||||
this value--its type may change in the future and is not part
|
||||
of the supported API.
|
||||
*/
|
||||
AtomicInt32 ReferenceCountedObject_refCount;
|
||||
|
||||
/**
|
||||
Linked list of all weak pointers that reference this (some may be
|
||||
on the stack!). Do not use or explicitly manipulate this value.
|
||||
*/
|
||||
_WeakPtrLinkedList* ReferenceCountedObject_weakPointer;
|
||||
|
||||
protected:
|
||||
|
||||
ReferenceCountedObject() :
|
||||
ReferenceCountedObject_refCount(0),
|
||||
ReferenceCountedObject_weakPointer(0) {
|
||||
|
||||
debugAssertM(isValidHeapPointer(this),
|
||||
"Reference counted objects must be allocated on the heap.");
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/** Automatically called immediately before the object is deleted.
|
||||
This is not called from the destructor because it needs to be invoked
|
||||
before the subclass destructor.
|
||||
*/
|
||||
void ReferenceCountedObject_zeroWeakPointers() {
|
||||
// Tell all of my weak pointers that I'm gone.
|
||||
|
||||
_WeakPtrLinkedList* node = ReferenceCountedObject_weakPointer;
|
||||
|
||||
while (node != 0) {
|
||||
|
||||
// Notify the weak pointer that it is going away
|
||||
node->weakPtr->objectCollected();
|
||||
|
||||
// Free the node and advance
|
||||
_WeakPtrLinkedList* tmp = node;
|
||||
node = node->next;
|
||||
delete tmp;
|
||||
}
|
||||
}
|
||||
|
||||
virtual ~ReferenceCountedObject() {}
|
||||
|
||||
|
||||
/**
|
||||
Note: copies will initially start out with 0
|
||||
references and 0 weak references like any other object.
|
||||
*/
|
||||
ReferenceCountedObject(const ReferenceCountedObject& notUsed) :
|
||||
ReferenceCountedObject_refCount(0),
|
||||
ReferenceCountedObject_weakPointer(0) {
|
||||
(void)notUsed;
|
||||
debugAssertM(G3D::isValidHeapPointer(this),
|
||||
"Reference counted objects must be allocated on the heap.");
|
||||
}
|
||||
|
||||
ReferenceCountedObject& operator=(const ReferenceCountedObject& other) {
|
||||
(void)other;
|
||||
// Nothing changes when I am assigned; the reference count on
|
||||
// both objects is the same (although my super-class probably
|
||||
// changes).
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
/**
|
||||
Use ReferenceCountedPointer<T> in place of T* in your program.
|
||||
T must subclass ReferenceCountedObject.
|
||||
@deprecated To be replaced by boost::shared_ptr in 7.0
|
||||
*/
|
||||
template <class T>
|
||||
class ReferenceCountedPointer {
|
||||
private:
|
||||
|
||||
T* m_pointer;
|
||||
|
||||
public:
|
||||
typedef T element_type;
|
||||
|
||||
inline T* pointer() const {
|
||||
return m_pointer;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
/** Nulls out the pointer and drops a reference. If the reference
|
||||
count hits zero. */
|
||||
void zeroPointer() {
|
||||
if (m_pointer != NULL) {
|
||||
|
||||
debugAssert(G3D::isValidHeapPointer(m_pointer));
|
||||
debugAssertM(m_pointer->ReferenceCountedObject_refCount.value() > 0,
|
||||
"Dangling reference detected.");
|
||||
|
||||
// Only delete if this instance caused the count to hit
|
||||
// exactly zero. If there is a race condition, the value
|
||||
// may be zero after decrement returns, but only one of
|
||||
// the instances will get a zero return value.
|
||||
if (m_pointer->ReferenceCountedObject_refCount.decrement() == 0) {
|
||||
// We held the last reference, so delete the object.
|
||||
// This test is threadsafe because there is no way for
|
||||
// the reference count to increase after the last
|
||||
// reference was dropped (assuming the application does
|
||||
// not voilate the class abstraction).
|
||||
//debugPrintf(" delete 0x%x\n", m_pointer);
|
||||
|
||||
// We must zero the weak pointers *before* deletion in case there
|
||||
// are cycles of weak references.
|
||||
// Note that since there are no strong references at this point,
|
||||
// it is perfectly fair to zero the weak pointers anyway.
|
||||
m_pointer->ReferenceCountedObject_zeroWeakPointers();
|
||||
delete m_pointer;
|
||||
}
|
||||
|
||||
m_pointer = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/** Non-atomic (except for the referencec increment). Can only be
|
||||
called in contexts like the copy constructor or initial
|
||||
constructor where it is known that the reference count will
|
||||
not hit zero on some other thread. */
|
||||
void setPointer(T* x) {
|
||||
if (x != m_pointer) {
|
||||
zeroPointer();
|
||||
|
||||
if (x != NULL) {
|
||||
debugAssert(G3D::isValidHeapPointer(x));
|
||||
|
||||
m_pointer = x;
|
||||
|
||||
// Note that the ref count can be zero if this is the
|
||||
// first pointer to it
|
||||
debugAssertM(m_pointer->ReferenceCountedObject_refCount.value() >= 0,
|
||||
"Negative reference count detected.");
|
||||
m_pointer->ReferenceCountedObject_refCount.increment();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
inline ReferenceCountedPointer() : m_pointer(NULL) {}
|
||||
|
||||
/**
|
||||
Allow silent cast <i>to</i> the base class.
|
||||
|
||||
<pre>
|
||||
SubRef s = new Sub();
|
||||
BaseRef b = s;
|
||||
</pre>
|
||||
|
||||
i.e., compile-time subtyping rule
|
||||
RCP<<I>T</I>> <: RCP<<I>S</I>> if <I>T</I> <: <I>S</I>
|
||||
*/
|
||||
template <class S>
|
||||
inline ReferenceCountedPointer(const ReferenceCountedPointer<S>& p) :
|
||||
m_pointer(NULL) {
|
||||
setPointer(p.pointer());
|
||||
}
|
||||
|
||||
# if (! defined(MSC_VER) || (MSC_VER >= 1300))
|
||||
/**
|
||||
Explicit cast to a subclass. Acts like dynamic cast; the result will be NULL if
|
||||
the cast cannot succeed. Not supported on VC6.
|
||||
<pre>
|
||||
SubRef s = new Sub();
|
||||
BaseRef b = s;
|
||||
s = b.downcast<Sub>(); // Note that the template argument is the object type, not the pointer type.
|
||||
</pre>
|
||||
*/
|
||||
template <class S>
|
||||
ReferenceCountedPointer<S> downcast() {
|
||||
return ReferenceCountedPointer<S>(dynamic_cast<S*>(m_pointer));
|
||||
}
|
||||
|
||||
template <class S>
|
||||
const ReferenceCountedPointer<S> downcast() const {
|
||||
return ReferenceCountedPointer<S>(dynamic_cast<const S*>(m_pointer));
|
||||
}
|
||||
# endif
|
||||
|
||||
// We need an explicit version of the copy constructor as well or
|
||||
// the default copy constructor will be used.
|
||||
inline ReferenceCountedPointer(const ReferenceCountedPointer<T>& p) : m_pointer(NULL) {
|
||||
setPointer(p.m_pointer);
|
||||
}
|
||||
|
||||
/** Allows construction from a raw pointer. That object will thereafter be
|
||||
reference counted -- do not call delete on it. */
|
||||
inline ReferenceCountedPointer(T* p) : m_pointer(NULL) {
|
||||
setPointer(p);
|
||||
}
|
||||
|
||||
inline ~ReferenceCountedPointer() {
|
||||
zeroPointer();
|
||||
}
|
||||
|
||||
inline size_t hashCode() const {
|
||||
return reinterpret_cast<size_t>(m_pointer);;
|
||||
}
|
||||
|
||||
inline const ReferenceCountedPointer<T>& operator=(const ReferenceCountedPointer<T>& p) {
|
||||
setPointer(p.m_pointer);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline ReferenceCountedPointer<T>& operator=(T* p) {
|
||||
setPointer(p);
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline bool operator==(const ReferenceCountedPointer<T>& y) const {
|
||||
return (m_pointer == y.m_pointer);
|
||||
}
|
||||
|
||||
inline bool operator!=(const ReferenceCountedPointer<T>& y) const {
|
||||
return (m_pointer != y.m_pointer);
|
||||
}
|
||||
|
||||
bool operator < (const ReferenceCountedPointer<T>& y) const {
|
||||
return (m_pointer < y.m_pointer);
|
||||
}
|
||||
|
||||
bool operator > (const ReferenceCountedPointer<T>& y) const {
|
||||
return (m_pointer > y.m_pointer);
|
||||
}
|
||||
|
||||
bool operator <= (const ReferenceCountedPointer<T>& y) const {
|
||||
return (m_pointer <= y.m_pointer);
|
||||
}
|
||||
|
||||
bool operator >= (const ReferenceCountedPointer<T>& y) const {
|
||||
return (m_pointer >= y.m_pointer);
|
||||
}
|
||||
|
||||
inline T& operator*() const {
|
||||
debugAssertM(m_pointer != NULL, "Dereferenced a NULL ReferenceCountedPointer");
|
||||
return (*m_pointer);
|
||||
}
|
||||
|
||||
inline T* operator->() const {
|
||||
debugAssertM(m_pointer != NULL, "Dereferenced a NULL ReferenceCountedPointer");
|
||||
return m_pointer;
|
||||
}
|
||||
|
||||
inline bool isNull() const {
|
||||
return (m_pointer == NULL);
|
||||
}
|
||||
|
||||
inline bool notNull() const {
|
||||
return (m_pointer != NULL);
|
||||
}
|
||||
|
||||
// TODO: distinguish between last strong and last any pointer
|
||||
/**
|
||||
Returns true if this is the last reference to an object.
|
||||
Useful for flushing memoization caches-- a cache that holds the last
|
||||
reference is unnecessarily keeping an object alive.
|
||||
|
||||
<b>Not threadsafe.</b>
|
||||
|
||||
@deprecated Use WeakReferenceCountedPointer for caches
|
||||
*/
|
||||
inline int isLastReference() const {
|
||||
return (m_pointer->ReferenceCountedObject_refCount.value() == 1);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
A weak pointer allows the object it references to be garbage collected.
|
||||
Weak pointers are commonly used in caches, where it is important to hold
|
||||
a pointer to an object without keeping that object alive solely for the
|
||||
cache's benefit (i.e., the object can be collected as soon as all
|
||||
pointers to it <B>outside</B> the cache are gone). They are also convenient
|
||||
for adding back-pointers in tree and list structures.
|
||||
|
||||
Weak pointers may become NULL at any point (when their target is collected).
|
||||
Therefore the only way to reference the target is to convert to a strong
|
||||
pointer and then check that it is not NULL.
|
||||
|
||||
@deprecated To be replaced by boost::weak_ptr in 7.0
|
||||
*/
|
||||
template <class T>
|
||||
class WeakReferenceCountedPointer : public _WeakPtr {
|
||||
private:
|
||||
|
||||
/** NULL if the object has been collected. */
|
||||
T* pointer;
|
||||
|
||||
public:
|
||||
/**
|
||||
Creates a strong pointer, which prevents the object from being
|
||||
garbage collected. The strong pointer may be NULL, which means
|
||||
that the underlying.
|
||||
*/
|
||||
// There is intentionally no way to check if the
|
||||
// WeakReferenceCountedPointer has a null reference without
|
||||
// creating a strong pointer since there is no safe way to use
|
||||
// that information-- the pointer could be collected by a
|
||||
// subsequent statement.
|
||||
ReferenceCountedPointer<T> createStrongPtr() const {
|
||||
// TODO: What if the object's destructor is called while we
|
||||
// are in this method?
|
||||
return ReferenceCountedPointer<T>(pointer);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
/**
|
||||
Thread issues: safe because this is only called when another
|
||||
object is guaranteed to keep p alive for the duration of this
|
||||
call.
|
||||
*/
|
||||
void setPointer(T* p) {
|
||||
// TODO: must prevent the object from being collected while in
|
||||
// this method
|
||||
|
||||
zeroPointer();
|
||||
pointer = p;
|
||||
|
||||
if (pointer != 0) {
|
||||
// TODO: threadsafe: must update the list atomically
|
||||
|
||||
// Add myself to the head of my target's list of weak pointers
|
||||
_WeakPtrLinkedList* head =
|
||||
new _WeakPtrLinkedList
|
||||
(this,
|
||||
pointer->ReferenceCountedObject_weakPointer);
|
||||
|
||||
pointer->ReferenceCountedObject_weakPointer = head;
|
||||
} else {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Removes this from its target's list of weak pointers. Called
|
||||
when the weak pointer goes out of scope.
|
||||
|
||||
Thread issues: depends on the thread safety of createStrongPtr.
|
||||
*/
|
||||
void zeroPointer() {
|
||||
// Grab a strong reference to prevent the object from being collected while we
|
||||
// are traversing its list.
|
||||
ReferenceCountedPointer<T> strong = createStrongPtr();
|
||||
|
||||
// If the following test fails then the object was collected before we
|
||||
// reached it.
|
||||
if (strong.notNull()) {
|
||||
debugAssertM(pointer->ReferenceCountedObject_weakPointer != NULL,
|
||||
"Weak pointer exists without a backpointer from the object.");
|
||||
|
||||
// Remove myself from my target's list of weak pointers
|
||||
_WeakPtrLinkedList** node = &pointer->ReferenceCountedObject_weakPointer;
|
||||
while ((*node)->weakPtr != this) {
|
||||
node = &((*node)->next);
|
||||
debugAssertM(*node != NULL,
|
||||
"Weak pointer exists without a backpointer from the object (2).");
|
||||
}
|
||||
|
||||
// Node must now point at the node for me. Remove node and
|
||||
// close the linked list behind it.
|
||||
_WeakPtrLinkedList* temp = *node;
|
||||
*node = temp->next;
|
||||
|
||||
// Now delete the node corresponding to me
|
||||
delete temp;
|
||||
}
|
||||
|
||||
pointer = NULL;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
WeakReferenceCountedPointer() : pointer(0) {}
|
||||
|
||||
/**
|
||||
Allow compile time subtyping rule
|
||||
RCP<<I>T</I>> <: RCP<<I>S</I>> if <I>T</I> <: <I>S</I>
|
||||
*/
|
||||
template <class S>
|
||||
inline WeakReferenceCountedPointer(const WeakReferenceCountedPointer<S>& p) : pointer(0) {
|
||||
// Threadsafe: the object cannot be collected while the other pointer exists.
|
||||
setPointer(p.pointer);
|
||||
}
|
||||
|
||||
template <class S>
|
||||
inline WeakReferenceCountedPointer(const ReferenceCountedPointer<S>& p) : pointer(0) {
|
||||
// Threadsafe: the object cannot be collected while the other
|
||||
// pointer exists.
|
||||
setPointer(p.pointer());
|
||||
}
|
||||
|
||||
// Gets called a *lot* when weak pointers are on the stack
|
||||
WeakReferenceCountedPointer(
|
||||
const WeakReferenceCountedPointer<T>& weakPtr) : pointer(0) {
|
||||
setPointer(weakPtr.pointer);
|
||||
}
|
||||
|
||||
WeakReferenceCountedPointer(
|
||||
const ReferenceCountedPointer<T>& strongPtr) : pointer(0) {
|
||||
setPointer(strongPtr.pointer());
|
||||
}
|
||||
|
||||
~WeakReferenceCountedPointer() {
|
||||
zeroPointer();
|
||||
}
|
||||
|
||||
WeakReferenceCountedPointer<T>& operator=(const WeakReferenceCountedPointer<T>& other) {
|
||||
// Threadsafe: the object cannot be collected while the other pointer exists.
|
||||
|
||||
// I now point at other's target
|
||||
setPointer(other.pointer);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
WeakReferenceCountedPointer<T>& operator=(const ReferenceCountedPointer<T>& other) {
|
||||
|
||||
// Threadsafe: the object cannot be collected while the other pointer exists.
|
||||
|
||||
// I now point at other's target
|
||||
setPointer(other.pointer());
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool operator==(const WeakReferenceCountedPointer<T>& other) const {
|
||||
return pointer == other.pointer;
|
||||
}
|
||||
|
||||
bool operator!=(const WeakReferenceCountedPointer<T>& other) const {
|
||||
return pointer != other.pointer;
|
||||
}
|
||||
|
||||
bool operator < (const WeakReferenceCountedPointer<T>& y) const {
|
||||
return (pointer < y.pointer);
|
||||
}
|
||||
|
||||
bool operator > (const WeakReferenceCountedPointer<T>& y) const {
|
||||
return (pointer > y.pointer);
|
||||
}
|
||||
|
||||
bool operator <= (const WeakReferenceCountedPointer<T>& y) const {
|
||||
return (pointer <= y.pointer);
|
||||
}
|
||||
|
||||
bool operator >= (const ReferenceCountedPointer<T>& y) const {
|
||||
return (pointer >= y.pointer);
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
/** Invoked by the destructor on ReferenceCountedPointer. */
|
||||
virtual void objectCollected() {
|
||||
debugAssertM(pointer != NULL,
|
||||
"Removed a weak pointer twice.");
|
||||
pointer = NULL;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
/**
|
||||
@file RegistryUtil.h
|
||||
|
||||
@created 2006-04-06
|
||||
@edited 2006-04-06
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_REGISTRYUTIL_H
|
||||
#define G3D_REGISTRYUTIL_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
// This file is only used on Windows
|
||||
#ifdef G3D_WIN32
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Provides generalized Windows registry querying.
|
||||
|
||||
All key names are one string in the format:
|
||||
"[base key]\[sub-keys]"
|
||||
|
||||
A value must now be provided for every query.
|
||||
An empty value string will use the (Default) value.
|
||||
|
||||
[base key] can be any of the following:
|
||||
HKEY_CLASSES_ROOT
|
||||
HKEY_CURRENT_CONFIG
|
||||
HKEY_CURRENT_USER
|
||||
HKEY_LOCAL_MACHINE
|
||||
HKEY_PERFORMANCE_DATA
|
||||
HKEY_PERFORMANCE_NLSTEXT
|
||||
HKEY_PERFORMANCE_TEXT
|
||||
HKEY_USERS
|
||||
|
||||
valueExists() should be used to validate a key+value before reading or writing
|
||||
to ensure that a debug assert or false return is for a different error during
|
||||
reads and writes.
|
||||
|
||||
All read and write calls will assert when a key will not open for reasons other
|
||||
that it does not exist. All read and write calls will assert when the value cannot
|
||||
be read or written for any reason.
|
||||
*/
|
||||
class RegistryUtil {
|
||||
|
||||
public:
|
||||
/** returns true if the key exists and the current user has permission to read */
|
||||
static bool keyExists(const std::string& key);
|
||||
|
||||
/** returns true if the key exists and the current user has permission to read */
|
||||
static bool valueExists(const std::string& key, const std::string& value);
|
||||
|
||||
/** returns false if the key could not be read for any reason. */
|
||||
static bool readInt32(const std::string& key, const std::string& value, int32& data);
|
||||
|
||||
/**
|
||||
Reads an arbitrary amount of data from a binary registry key.
|
||||
returns false if the key could not be read for any reason.
|
||||
|
||||
@beta
|
||||
@param data pointer to the output buffer of sufficient size. Pass NULL as data in order to have available data size returned in dataSize.
|
||||
@param dataSize size of the output buffer. When NULL is passed for data, contains the size of available data on successful return.
|
||||
*/
|
||||
static bool readBytes(const std::string& key, const std::string& value, uint8* data, uint32& dataSize);
|
||||
|
||||
/** returns false if the key could not be read for any reason. */
|
||||
static bool readString(const std::string& key, const std::string& value, std::string& data);
|
||||
|
||||
/** returns false if the key could not be written for any reason. */
|
||||
static bool writeInt32(const std::string& key, const std::string& value, int32 data);
|
||||
|
||||
/**
|
||||
Writes an arbitrary amount of data to a binary registry key.
|
||||
returns false if the key could not be written for any reason.
|
||||
|
||||
@param data pointer to the input buffer
|
||||
@param dataSize size of the input buffer that should be written
|
||||
*/
|
||||
static bool writeBytes(const std::string& key, const std::string& value, const uint8* data, uint32 dataSize);
|
||||
|
||||
/** returns false if the key could not be written for any reason. */
|
||||
static bool writeString(const std::string& key, const std::string& value, const std::string& data);
|
||||
|
||||
};
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
#endif // G3D_WIN32
|
||||
|
||||
#endif // G3D_REGISTRYTUIL_H
|
||||
+160
@@ -0,0 +1,160 @@
|
||||
/**
|
||||
@file Set.h
|
||||
|
||||
Hash set
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-12-09
|
||||
@edited 2006-02-20
|
||||
*/
|
||||
|
||||
#ifndef G3D_SET_H
|
||||
#define G3D_SET_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Table.h"
|
||||
#include <assert.h>
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
An unordered data structure that has at most one of each element.
|
||||
Provides O(1) time insert, remove, and member test (contains).
|
||||
|
||||
Set uses G3D::Table internally, which means that the template type T
|
||||
must define a hashCode and operator== function. See G3D::Table for
|
||||
a discussion of these functions.
|
||||
*/
|
||||
// There is not copy constructor or assignment operator defined because
|
||||
// the default ones are correct for Set.
|
||||
template<class T>
|
||||
class Set {
|
||||
|
||||
/**
|
||||
If an object is a member, it is contained in
|
||||
this table.
|
||||
*/
|
||||
Table<T, bool> memberTable;
|
||||
|
||||
public:
|
||||
|
||||
virtual ~Set() {}
|
||||
|
||||
int size() const {
|
||||
return (int)memberTable.size();
|
||||
}
|
||||
|
||||
bool contains(const T& member) const {
|
||||
return memberTable.containsKey(member);
|
||||
}
|
||||
|
||||
/**
|
||||
Inserts into the table if not already present.
|
||||
*/
|
||||
void insert(const T& member) {
|
||||
memberTable.set(member, true);
|
||||
}
|
||||
|
||||
/**
|
||||
It is an error to remove members that are not already
|
||||
present.
|
||||
*/
|
||||
void remove(const T& member) {
|
||||
memberTable.remove(member);
|
||||
}
|
||||
|
||||
Array<T> getMembers() const {
|
||||
return memberTable.getKeys();
|
||||
}
|
||||
|
||||
void getMembers(Array<T>& keyArray) const {
|
||||
memberTable.getKeys(keyArray);
|
||||
}
|
||||
|
||||
void clear() {
|
||||
memberTable.clear();
|
||||
}
|
||||
|
||||
void deleteAll() {
|
||||
getMembers().deleteAll();
|
||||
clear();
|
||||
}
|
||||
|
||||
/**
|
||||
C++ STL style iterator variable. See begin().
|
||||
*/
|
||||
class Iterator {
|
||||
private:
|
||||
friend class Set<T>;
|
||||
|
||||
// Note: this is a Table iterator, we are currently defining
|
||||
// Set iterator
|
||||
typename Table<T, bool>::Iterator it;
|
||||
|
||||
Iterator(const typename Table<T, bool>::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;
|
||||
}
|
||||
|
||||
/**
|
||||
Post increment (slower than preincrement).
|
||||
*/
|
||||
Iterator operator++(int) {
|
||||
Iterator old = *this;
|
||||
++(*this);
|
||||
return old;
|
||||
}
|
||||
|
||||
const T& operator*() const {
|
||||
return it->key;
|
||||
}
|
||||
|
||||
T* operator->() const {
|
||||
return &(it->key);
|
||||
}
|
||||
|
||||
operator T*() const {
|
||||
return &(it->key);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
C++ STL style iterator method. Returns the first member.
|
||||
Use preincrement (++entry) to get to the next element.
|
||||
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.
|
||||
*/
|
||||
const Iterator end() const {
|
||||
return Iterator(memberTable.end());
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
+143
@@ -0,0 +1,143 @@
|
||||
/**
|
||||
@file Sphere.h
|
||||
|
||||
Sphere class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2008-10-07
|
||||
*/
|
||||
|
||||
#ifndef G3D_SPHERE_H
|
||||
#define G3D_SPHERE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Sphere.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Sphere.
|
||||
*/
|
||||
class Sphere {
|
||||
private:
|
||||
|
||||
static int32 dummy;
|
||||
|
||||
public:
|
||||
Vector3 center;
|
||||
float radius;
|
||||
|
||||
Sphere() {
|
||||
center = Vector3::zero();
|
||||
radius = 0;
|
||||
}
|
||||
|
||||
Sphere(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
Sphere(
|
||||
const Vector3& center,
|
||||
float radius) {
|
||||
|
||||
this->center = center;
|
||||
this->radius = radius;
|
||||
}
|
||||
|
||||
virtual ~Sphere() {}
|
||||
|
||||
bool operator==(const Sphere& other) const {
|
||||
return (center == other.center) && (radius == other.radius);
|
||||
}
|
||||
|
||||
bool operator!=(const Sphere& other) const {
|
||||
return !((center == other.center) && (radius == other.radius));
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if point is less than or equal to radius away from
|
||||
the center.
|
||||
*/
|
||||
bool contains(const Vector3& point) const;
|
||||
|
||||
/**
|
||||
@deprecated Use culledBy(Array<Plane>&)
|
||||
*/
|
||||
bool culledBy(
|
||||
const class Plane* plane,
|
||||
int numPlanes,
|
||||
int32& cullingPlaneIndex,
|
||||
const uint32 testMask,
|
||||
uint32& childMask) const;
|
||||
|
||||
/**
|
||||
@deprecated Use culledBy(Array<Plane>&)
|
||||
*/
|
||||
bool culledBy(
|
||||
const class Plane* plane,
|
||||
int numPlanes,
|
||||
int32& cullingPlaneIndex = dummy,
|
||||
const uint32 testMask = 0xFFFFFFFF) const;
|
||||
|
||||
/**
|
||||
See AABox::culledBy
|
||||
*/
|
||||
bool culledBy(
|
||||
const Array<Plane>& plane,
|
||||
int32& cullingPlaneIndex,
|
||||
const uint32 testMask,
|
||||
uint32& childMask) const;
|
||||
|
||||
/**
|
||||
Conservative culling test that does not produce a mask for children.
|
||||
*/
|
||||
bool culledBy(
|
||||
const Array<Plane>& plane,
|
||||
int32& cullingPlaneIndex = dummy,
|
||||
const uint32 testMask = 0xFFFFFFFF) const;
|
||||
|
||||
virtual std::string toString() const;
|
||||
|
||||
float volume() const;
|
||||
|
||||
float area() const;
|
||||
|
||||
/**
|
||||
Uniformly distributed on the surface.
|
||||
*/
|
||||
Vector3 randomSurfacePoint() const;
|
||||
|
||||
/**
|
||||
Uniformly distributed on the interior (includes surface)
|
||||
*/
|
||||
Vector3 randomInteriorPoint() const;
|
||||
|
||||
void getBounds(class AABox& out) const;
|
||||
|
||||
bool intersects(const Sphere& other) const;
|
||||
|
||||
/** Translates the sphere */
|
||||
Sphere operator+(const Vector3& v) const {
|
||||
return Sphere(center + v, radius);
|
||||
}
|
||||
|
||||
/** Translates the sphere */
|
||||
Sphere operator-(const Vector3& v) const {
|
||||
return Sphere(center - v, radius);
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template <> struct HashTrait<G3D::Sphere> {
|
||||
static size_t hashCode(const G3D::Sphere& key) {
|
||||
return static_cast<size_t>(key.center.hashCode() + (key.radius * 13));
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
+367
@@ -0,0 +1,367 @@
|
||||
/**
|
||||
@file Spline.h
|
||||
|
||||
@author Morgan McGuire, [email protected]
|
||||
*/
|
||||
|
||||
#ifndef G3D_SPLINE_H
|
||||
#define G3D_SPLINE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Matrix4.h"
|
||||
#include "G3D/Vector4.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/** Common implementation code for all G3D::Spline template parameters */
|
||||
class SplineBase {
|
||||
public:
|
||||
|
||||
/** Times at which control points occur. Must have the same
|
||||
number of elements as Spline::control. */
|
||||
Array<float> time;
|
||||
|
||||
/** If cyclic, then the control points will be assumed to wrap around.
|
||||
If not cyclic, then the tangents at the ends of the spline
|
||||
point to the final control points.*/
|
||||
bool cyclic;
|
||||
|
||||
/** For a cyclic spline, this is the time elapsed between the last
|
||||
control point and the first. If less than or equal to zero this is
|
||||
assumed to be:
|
||||
|
||||
(time[0] - time[1] + .
|
||||
time[time.size() - 1] - time[time.size() - 2]) / 2.
|
||||
*/
|
||||
float finalInterval;
|
||||
|
||||
SplineBase() : cyclic(true), finalInterval(-1) {}
|
||||
|
||||
virtual ~SplineBase() {}
|
||||
|
||||
/** See specification for Spline::finalInterval; this handles the
|
||||
non-positive case. Returns 0 if not cyclic. */
|
||||
float getFinalInterval() const;
|
||||
|
||||
/** Returns the amount of time covered by this spline in one
|
||||
period. For a cyclic spline, this contains the final
|
||||
interval.*/
|
||||
float duration() const;
|
||||
|
||||
/** Computes the derivative spline basis from the control point version. */
|
||||
static Matrix4 computeBasis();
|
||||
|
||||
protected:
|
||||
|
||||
/** Assumes that t0 <= s < tn. called by computeIndex. */
|
||||
void computeIndexInBounds(float s, int& i, float& u) const;
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
Given a time @a s, finds @a i and 0 <= @a u < 1 such that
|
||||
@s = time[@a i] * @a u + time[@a i + 1] * (1 - @a u). Note that
|
||||
@i may be outside the bounds of the time and control arrays;
|
||||
use getControl to handle wraparound and extrapolation issues.
|
||||
|
||||
This function takes expected O(1) time for control points with
|
||||
uniform time sampled control points or for uniformly
|
||||
distributed random time samples, but may take O( log time.size() ) time
|
||||
in the worst case.
|
||||
|
||||
Called from evaluate().
|
||||
*/
|
||||
void computeIndex(float s, int& i, float& u) const;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
Smooth parameteric curve implemented using a piecewise 3rd-order
|
||||
Catmull-Rom spline curve. The spline is considered infinite and may
|
||||
either continue linearly from the specified control points or cycle
|
||||
through them. Control points are spaced uniformly in time at unit
|
||||
intervals by default, but irregular spacing may be explicitly
|
||||
specified.
|
||||
|
||||
The dimension of the spline can be set by varying the Control
|
||||
template parameter. For a 1D function, use Spline<float>. For a
|
||||
curve in the plane, Spline<Vector2>. Note that <i>any</i> template
|
||||
parameter that supports operator+(Control) and operator*(float) can
|
||||
be used; you can make splines out of G3D::Vector4, G3D::Matrix3, or
|
||||
your own classes.
|
||||
|
||||
To provide shortest-path interpolation, subclass G3D::Spline and
|
||||
override ensureShortestPath(). To provide normalization of
|
||||
interpolated points (e.g., projecting Quats onto the unit
|
||||
hypersphere) override correct().
|
||||
|
||||
See Real Time Rendering, 2nd edition, ch 12 for a general discussion
|
||||
of splines and their properties.
|
||||
|
||||
@sa G3D::UprightSpline, G3D::QuatSpline
|
||||
*/
|
||||
template<typename Control>
|
||||
class Spline : public SplineBase {
|
||||
protected:
|
||||
/** The additive identity control point. */
|
||||
Control zero;
|
||||
|
||||
public:
|
||||
|
||||
/** Control points. Must have the same number of elements as
|
||||
Spline::time.*/
|
||||
Array<Control> control;
|
||||
|
||||
Spline() {
|
||||
static Control x;
|
||||
// Hide the fact from C++ that we are using an
|
||||
// uninitialized variable here by pointer arithmetic.
|
||||
// This is ok because any type that is a legal control
|
||||
// point also supports multiplication by float.
|
||||
zero = *(&x) * 0.0f;
|
||||
}
|
||||
|
||||
/** Appends a control point at a specific time that must be
|
||||
greater than that of the previous point. */
|
||||
void append(float t, const Control& c) {
|
||||
debugAssertM((time.size() == 0) || (t > time.last()),
|
||||
"Control points must have monotonically increasing times.");
|
||||
time.append(t);
|
||||
control.append(c);
|
||||
debugAssert(control.size() == time.size());
|
||||
}
|
||||
|
||||
|
||||
/** Appends control point spaced in time based on the previous
|
||||
control point, or spaced at unit intervals if this is the
|
||||
first control point. */
|
||||
void append(const Control& c) {
|
||||
switch (time.size()) {
|
||||
case 0:
|
||||
append(0, c);
|
||||
break;
|
||||
|
||||
case 1:
|
||||
if (time[0] == 0) {
|
||||
append(1, c);
|
||||
} else {
|
||||
append(time[0], c);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
append(2 * time[time.size() - 1] - time[time.size() - 2], c);
|
||||
}
|
||||
debugAssert(control.size() == time.size());
|
||||
}
|
||||
|
||||
/** Erases all control points and times, but retains the state of
|
||||
cyclic and finalInterval.
|
||||
*/
|
||||
void clear() {
|
||||
control.clear();
|
||||
time.clear();
|
||||
}
|
||||
|
||||
|
||||
/** Number of control points */
|
||||
int size() const {
|
||||
debugAssert(time.size() == control.size());
|
||||
return control.size();
|
||||
}
|
||||
|
||||
|
||||
/** Returns the requested control point and time sample based on
|
||||
array index. If the array index is out of bounds, wraps (for
|
||||
a cyclic spline) or linearly extrapolates (for a non-cyclic
|
||||
spline), assuming time intervals follow the first or last
|
||||
sample recorded.
|
||||
|
||||
Calls correct() on the control point if it was extrapolated.
|
||||
|
||||
Returns 0 if there are no control points.
|
||||
|
||||
@sa Spline::control and Spline::time for the underlying
|
||||
control point array; Spline::computeIndex to find the index
|
||||
given a time.
|
||||
*/
|
||||
void getControl(int i, float& t, Control& c) const {
|
||||
int N = control.size();
|
||||
if (N == 0) {
|
||||
c = zero;
|
||||
t = 0;
|
||||
} else if (cyclic) {
|
||||
c = control[iWrap(i, N)];
|
||||
|
||||
if (i < 0) {
|
||||
// Wrapped around bottom
|
||||
|
||||
// Number of times we wrapped around the cyclic array
|
||||
int wraps = (N + 1 - i) / N;
|
||||
int j = (i + wraps * N) % N;
|
||||
t = time[j] - wraps * duration();
|
||||
|
||||
} else if (i < N) {
|
||||
|
||||
t = time[i];
|
||||
|
||||
} else {
|
||||
// Wrapped around top
|
||||
|
||||
// Number of times we wrapped around the cyclic array
|
||||
int wraps = i / N;
|
||||
int j = i % N;
|
||||
t = time[j] + wraps * duration();
|
||||
}
|
||||
|
||||
} else if (i < 0) {
|
||||
// Are there enough points to extrapolate?
|
||||
if (N >= 2) {
|
||||
// Step away from control point 0
|
||||
float dt = time[1] - time[0];
|
||||
|
||||
// Extrapolate (note; i is negative)
|
||||
c = control[1] * float(i) + control[0] * float(1 - i);
|
||||
correct(c);
|
||||
t = dt * i + time[0];
|
||||
|
||||
} else {
|
||||
// Just clamp
|
||||
c = control[0];
|
||||
|
||||
// Only 1 time; assume 1s intervals
|
||||
t = time[0] + i;
|
||||
}
|
||||
|
||||
} else if (i >= N) {
|
||||
if (N >= 2) {
|
||||
float dt = time[N - 1] - time[N - 2];
|
||||
|
||||
// Extrapolate
|
||||
c = control[N - 1] * float(i - N + 2) + control[N - 2] * -float(i - N + 1);
|
||||
correct(c);
|
||||
t = time[N - 1] + dt * (i - N + 1);
|
||||
|
||||
} else {
|
||||
// Return the last, clamping
|
||||
c = control.last();
|
||||
// Only 1 time; assume 1s intervals
|
||||
t = time[0] + i;
|
||||
}
|
||||
} else {
|
||||
// In bounds
|
||||
c = control[i];
|
||||
t = time[i];
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
/** Returns a series of N control points and times, fixing
|
||||
boundary issues. The indices may be assumed to be treated
|
||||
cyclically. */
|
||||
void getControls(int i, float* T, Control* A, int N) const {
|
||||
for (int j = 0; j < N; ++j) {
|
||||
getControl(i + j, T[j], A[j]);
|
||||
}
|
||||
ensureShortestPath(A, N);
|
||||
}
|
||||
|
||||
/**
|
||||
Mutates the array of N control points. It is useful to override this
|
||||
method by one that wraps the values if they are angles or quaternions
|
||||
for which "shortest path" interpolation is significant.
|
||||
*/
|
||||
virtual void ensureShortestPath(Control* A, int N) const {}
|
||||
|
||||
/** Normalize or otherwise adjust this interpolated Control. */
|
||||
virtual void correct(Control& A) const {}
|
||||
|
||||
public:
|
||||
|
||||
|
||||
/**
|
||||
Return the position at time s. The spline is defined outside
|
||||
of the time samples by extrapolation or cycling.
|
||||
*/
|
||||
Control evaluate(float s) const {
|
||||
debugAssertM(control.size() == time.size(), "Corrupt spline: wrong number of control points.");
|
||||
|
||||
/*
|
||||
@cite http://www.gamedev.net/reference/articles/article1497.asp
|
||||
Derivation of basis matrix follows.
|
||||
|
||||
Given control points with positions p[i] at times t[i], 0 <= i <= 3, find the position
|
||||
at time t[1] <= s <= t[2].
|
||||
|
||||
Let u = s - t[0]
|
||||
Let U = [u^0 u^1 u^2 u^3] = [1 u u^2 u^3]
|
||||
Let dt0 = t[0] - t[-1]
|
||||
Let dt1 = t[1] - t[0]
|
||||
Let dt2 = t[2] - t[1]
|
||||
*/
|
||||
|
||||
// Index of the first control point (i.e., the u = 0 point)
|
||||
int i = 0;
|
||||
// Fractional part of the time
|
||||
float u = 0;
|
||||
|
||||
computeIndex(s, i, u);
|
||||
|
||||
Control p[4];
|
||||
float t[4];
|
||||
getControls(i - 1, t, p, 4);
|
||||
float dt0 = t[1] - t[0];
|
||||
float dt1 = t[2] - t[1];
|
||||
float dt2 = t[3] - t[2];
|
||||
|
||||
static const Matrix4 basis = computeBasis();
|
||||
|
||||
// Powers of u
|
||||
Vector4 uvec((float)(u*u*u), (float)(u*u), (float)u, 1.0f);
|
||||
|
||||
// Compute the weights on each of the control points.
|
||||
const Vector4& weights = uvec * basis;
|
||||
|
||||
// Compute the weighted sum of the neighboring control points.
|
||||
Control sum;
|
||||
|
||||
const Control& p0 = p[0];
|
||||
const Control& p1 = p[1];
|
||||
const Control& p2 = p[2];
|
||||
const Control& p3 = p[3];
|
||||
|
||||
const Control& dp0 = p1 + (p0*-1.0f);
|
||||
const Control& dp1 = p2 + (p1*-1.0f);
|
||||
const Control& dp2 = p3 + (p2*-1.0f);
|
||||
|
||||
// The factor of 1/2 from averaging two time intervals is
|
||||
// already factored into the basis
|
||||
|
||||
// tan1 = (dp0 / dt0 + dp1 / dt1) * ((dt0 + dt1) * 0.5);
|
||||
// The last term normalizes for unequal time intervals
|
||||
float x = (dt0 + dt1) * 0.5f;
|
||||
float n0 = x / dt0;
|
||||
float n1 = x / dt1;
|
||||
float n2 = x / dt2;
|
||||
const Control& dp1n1 = dp1 * n1;
|
||||
const Control& tan1 = dp0 * n0 + dp1n1;
|
||||
const Control& tan2 = dp1n1 + dp2 * n2;
|
||||
|
||||
sum =
|
||||
tan1 * weights[0]+
|
||||
p1 * weights[1] +
|
||||
p2 * weights[2] +
|
||||
tan2 * weights[3];
|
||||
|
||||
|
||||
correct(sum);
|
||||
return sum;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+108
@@ -0,0 +1,108 @@
|
||||
/**
|
||||
@file Stopwatch.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2005-10-05
|
||||
@edited 2005-10-05
|
||||
|
||||
Copyright 2000-2003, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_STOPWATCH_H
|
||||
#define G3D_STOPWATCH_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Queue.h"
|
||||
#include "G3D/G3DGameUnits.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Utility class for profiling duration and frame rates.
|
||||
*/
|
||||
class Stopwatch {
|
||||
private:
|
||||
/** True between tick and tock */
|
||||
bool inBetween;
|
||||
|
||||
/** The initial cycle count. */
|
||||
uint64 cycleStart;
|
||||
|
||||
/** The time at which tick was called. */
|
||||
RealTime timeStart;
|
||||
|
||||
/** The time at which the previous tock was called, -1 if never. */
|
||||
RealTime lastTockTime;
|
||||
|
||||
RealTime lastDuration;
|
||||
int64 lastCycleCount;
|
||||
|
||||
/** Frames per second. */
|
||||
double m_fps;
|
||||
|
||||
/** Weighted fps */
|
||||
double emwaFPS;
|
||||
double m_smoothFPS;
|
||||
|
||||
/** Weighted duration */
|
||||
RealTime emwaDuration;
|
||||
|
||||
/** The overhead for calling into the class. */
|
||||
int64 cycleOverhead;
|
||||
|
||||
/** Called from the constructor. */
|
||||
void computeOverhead();
|
||||
|
||||
public:
|
||||
|
||||
Stopwatch();
|
||||
|
||||
/** Returns the number of times that tick was called per wall-clock second;
|
||||
e.g. frames-per-second. */
|
||||
double FPS() const {
|
||||
return m_fps;
|
||||
}
|
||||
|
||||
/** Amount of time between the most recent tick and tock calls. 0 if tick has
|
||||
never been called. */
|
||||
RealTime elapsedTime() const {
|
||||
return lastDuration;
|
||||
}
|
||||
|
||||
/** Time-smoothed value that is stable to the nearest 1%.
|
||||
This is useful if you are displaying elapsed time in real-time
|
||||
and want a stable number.*/
|
||||
RealTime smoothElapsedTime() const {
|
||||
return emwaDuration;
|
||||
}
|
||||
|
||||
/** Time-smoothed value of fps that is stable to the nearest integer for fps > 10 and
|
||||
to the first decimal place for fps <= 10.
|
||||
This is useful if you
|
||||
are displaying the frame rate in real-time and want a stable (readable) number.*/
|
||||
double smoothFPS() const {
|
||||
return m_smoothFPS;
|
||||
}
|
||||
|
||||
/** The elapsed cycle time between tick and tock. An attempt is made to factor out all
|
||||
tick/tock overhead, so that back-to-back calls should return zero.
|
||||
Unreliable on non-x86 platforms.*/
|
||||
uint64 elapsedCycles() const {
|
||||
return lastCycleCount;
|
||||
}
|
||||
|
||||
/** Call at the beginning of the period that you want timed. */
|
||||
void tick();
|
||||
|
||||
/** Call at the end of the period that you want timed. */
|
||||
void tock();
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
+390
@@ -0,0 +1,390 @@
|
||||
/**
|
||||
@file System.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@cite Rob Wyatt http://www.gamasutra.com/features/wyatts_world/19990709/processor_detection_01.htm
|
||||
@cite Benjamin Jurke http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-ProcessorDetectionClass&forum=cotd&id=-1
|
||||
@cite Michael Herf http://www.stereopsis.com/memcpy.html
|
||||
|
||||
@created 2003-01-25
|
||||
@edited 2008-10-14
|
||||
*/
|
||||
|
||||
#ifndef G3D_SYSTEM_H
|
||||
#define G3D_SYSTEM_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/G3DGameUnits.h"
|
||||
#include "G3D/BinaryFormat.h"
|
||||
#include <string>
|
||||
|
||||
#ifdef G3D_OSX
|
||||
# include <CoreServices/CoreServices.h>
|
||||
#endif
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Routine used by the demos to find the data. Searches in
|
||||
../data, ../../data, etc. up to 5 levels back. Checks
|
||||
common locations like c:\libraries\g3d-<version>\data
|
||||
and some hard-coded paths on the Brown University file
|
||||
system.
|
||||
*/
|
||||
std::string demoFindData(bool errorIfNotFound = true);
|
||||
|
||||
/** G3D, SDL, and IJG libraries require license documentation
|
||||
to be distributed with your program. This generates the
|
||||
string that must appear in your documentation.
|
||||
<B>Your program can be commercial, closed-source</B> under
|
||||
any license you want.*/
|
||||
std::string license();
|
||||
|
||||
/**
|
||||
The order in which the bytes of an integer are stored on a machine. Intel/AMD chips tend to be G3D_LITTLE_ENDIAN, Mac PPC's and Suns are G3D_BIG_ENDIAN. However, this is primarily used to specify the byte order of file formats, which are fixed.
|
||||
*/
|
||||
enum G3DEndian {
|
||||
G3D_BIG_ENDIAN, G3D_LITTLE_ENDIAN
|
||||
};
|
||||
|
||||
/**
|
||||
OS and processor abstraction. The first time any method is called the processor
|
||||
will be analyzed. Future calls are then fast.
|
||||
|
||||
Timing function overview:
|
||||
System::getCycleCount
|
||||
- actual cycle count
|
||||
|
||||
System::getTick
|
||||
- High-resolution time in seconds since program started
|
||||
|
||||
System::getLocalTime
|
||||
- High-resolution time in seconds since Jan 1, 1970
|
||||
(because it is stored in a double, this may be less
|
||||
accurate than getTick)
|
||||
|
||||
*/
|
||||
class System {
|
||||
public:
|
||||
|
||||
/** Called automatically by the other System routines.*/
|
||||
static void init();
|
||||
|
||||
/** */
|
||||
static bool hasMMX();
|
||||
|
||||
/** */
|
||||
static bool hasCPUID();
|
||||
|
||||
/** */
|
||||
static bool hasSSE();
|
||||
|
||||
/** */
|
||||
static bool hasSSE2();
|
||||
|
||||
/** */
|
||||
static bool hasSSE3();
|
||||
|
||||
/** */
|
||||
static bool has3DNow();
|
||||
|
||||
|
||||
/** */
|
||||
static bool hasRDTSC();
|
||||
|
||||
static const std::string& cpuVendor();
|
||||
|
||||
/** e.g. "Windows", "GNU/Linux" */
|
||||
static const std::string& operatingSystem();
|
||||
|
||||
/** */
|
||||
static const std::string& cpuArchitecture();
|
||||
|
||||
/**
|
||||
Returns the endianness of this machine.
|
||||
*/
|
||||
static G3DEndian machineEndian();
|
||||
|
||||
/**
|
||||
Returns the current date as a string in the form YYYY-MM-DD
|
||||
*/
|
||||
static std::string currentDateString();
|
||||
|
||||
/**
|
||||
Guarantees that the start of the array is aligned to the
|
||||
specified number of bytes.
|
||||
*/
|
||||
static void* alignedMalloc(size_t bytes, size_t alignment);
|
||||
|
||||
/**
|
||||
Uses pooled storage to optimize small allocations (1 byte to 5 kilobytes).
|
||||
Can be 10x to 100x faster than calling ::malloc or new.
|
||||
|
||||
The result must be freed with free.
|
||||
|
||||
Threadsafe on Win32.
|
||||
|
||||
@sa calloc realloc OutOfMemoryCallback free
|
||||
*/
|
||||
static void* malloc(size_t bytes);
|
||||
|
||||
static void* calloc(size_t n, size_t x);
|
||||
|
||||
/**
|
||||
@param size Size of memory that the system was trying to allocate
|
||||
@param recoverable If true, the system will attempt to allocate again
|
||||
if the callback returns true. If false, malloc is going to return
|
||||
NULL and this invocation is just to notify the application.
|
||||
@return Return true to force malloc to attempt allocation again if the
|
||||
error was recoverable.
|
||||
*/
|
||||
typedef bool (*OutOfMemoryCallback)(size_t size, bool recoverable);
|
||||
|
||||
/**
|
||||
When System::malloc fails to allocate memory because the system is
|
||||
out of memory, it invokes this handler (if it is not NULL).
|
||||
The argument to the callback is the amount of memory that malloc
|
||||
was trying to allocate when it ran out. If the callback returns
|
||||
true, System::malloc will attempt to allocate the memory again.
|
||||
If the callback returns false, then System::malloc will return NULL.
|
||||
|
||||
You can use outOfMemoryCallback to free data structures or to
|
||||
register the failure.
|
||||
*/
|
||||
static OutOfMemoryCallback outOfMemoryCallback;
|
||||
|
||||
/**
|
||||
Version of realloc that works with System::malloc.
|
||||
*/
|
||||
static void* realloc(void* block, size_t bytes);
|
||||
|
||||
/** Returns a string describing how well System::malloc is using its internal pooled storage.
|
||||
"heap" memory was slow to allocate; the other data sizes are comparatively fast.*/
|
||||
static std::string mallocPerformance();
|
||||
static void resetMallocPerformanceCounters();
|
||||
|
||||
/**
|
||||
Returns a string describing the current usage of the buffer pools used for
|
||||
optimizing System::malloc.
|
||||
*/
|
||||
static std::string mallocStatus();
|
||||
|
||||
/**
|
||||
Free data allocated with System::malloc.
|
||||
|
||||
Threadsafe on Win32.
|
||||
*/
|
||||
static void free(void* p);
|
||||
|
||||
/**
|
||||
Frees memory allocated with alignedMalloc.
|
||||
*/
|
||||
static void alignedFree(void* ptr);
|
||||
|
||||
/** An implementation of memcpy that may be up to 2x as fast as the C library
|
||||
one on some processors. Guaranteed to have the same behavior as memcpy
|
||||
in all cases. */
|
||||
static void memcpy(void* dst, const void* src, size_t numBytes);
|
||||
|
||||
/** An implementation of memset that may be up to 2x as fast as the C library
|
||||
one on some processors. Guaranteed to have the same behavior as memset
|
||||
in all cases. */
|
||||
static void memset(void* dst, uint8 value, size_t numBytes);
|
||||
|
||||
/**
|
||||
Returns the fully qualified filename for the currently running executable.
|
||||
|
||||
This is more reliable than arg[0], which may be intentionally set
|
||||
to an incorrect value by a calling program, relative to a now
|
||||
non-current directory, or obfuscated by sym-links.
|
||||
|
||||
@cite Linux version written by Nicolai Haehnle <[email protected]>, http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-getexename&forum=cotd&id=-1
|
||||
*/
|
||||
static std::string currentProgramFilename();
|
||||
|
||||
/** Name of this program. Note that you can mutate this string to set your app name explicitly.*/
|
||||
static std::string& appName();
|
||||
|
||||
/** G3D Version string */
|
||||
static const std::string& version();
|
||||
|
||||
/**
|
||||
Either Debug or Release, depending on whether _DEBUG was defined at compile-time for the library.
|
||||
*/
|
||||
static const std::string& build();
|
||||
|
||||
/**
|
||||
Causes the current thread to yield for the specified duration
|
||||
and consume almost no CPU.
|
||||
The sleep will be extremely precise; it uses System::time()
|
||||
to calibrate the exact yeild time.
|
||||
*/
|
||||
static void sleep(RealTime t);
|
||||
|
||||
/**
|
||||
Clears the console.
|
||||
Console programs only.
|
||||
*/
|
||||
static void consoleClearScreen();
|
||||
|
||||
/**
|
||||
Returns true if a key is waiting.
|
||||
Console programs only.
|
||||
*/
|
||||
static bool consoleKeyPressed();
|
||||
|
||||
/**
|
||||
Blocks until a key is read (use consoleKeyPressed to determine if
|
||||
a key is waiting to be read) then returns the character code for
|
||||
that key.
|
||||
*/
|
||||
static int consoleReadKey();
|
||||
|
||||
/**
|
||||
The actual time (measured in seconds since
|
||||
Jan 1 1970 midnight).
|
||||
|
||||
Adjusted for local timezone and daylight savings
|
||||
time. This is as accurate and fast as getCycleCount().
|
||||
*/
|
||||
static RealTime time();
|
||||
|
||||
/**
|
||||
To count the number of cycles a given operation takes:
|
||||
|
||||
<PRE>
|
||||
unsigned long count;
|
||||
System::beginCycleCount(count);
|
||||
...
|
||||
System::endCycleCount(count);
|
||||
// count now contains the cycle count for the intervening operation.
|
||||
|
||||
*/
|
||||
static void beginCycleCount(uint64& cycleCount);
|
||||
static void endCycleCount(uint64& cycleCount);
|
||||
|
||||
static uint64 getCycleCount();
|
||||
|
||||
/** Set an environment variable for the current process */
|
||||
static void setEnv(const std::string& name, const std::string& value);
|
||||
|
||||
/** Get an environment variable for the current process. Returns NULL if the variable doesn't exist. */
|
||||
static const char* getEnv(const std::string& name);
|
||||
|
||||
/**
|
||||
Prints a human-readable description of this machine
|
||||
to the text output stream. Either argument may be NULL.
|
||||
*/
|
||||
static void describeSystem(
|
||||
class TextOutput& t);
|
||||
|
||||
static void describeSystem(
|
||||
std::string& s);
|
||||
|
||||
/** Returns the speed of processor 0 in MHz.
|
||||
Always returns 0 on linux.*/
|
||||
static int cpuSpeedMHz();
|
||||
|
||||
|
||||
/** On Win32, returns the clipboard text contents. Does nothing on other
|
||||
platforms (yet) */
|
||||
static std::string getClipboardText();
|
||||
|
||||
/** Copies the text to the clipboard on Win32. */
|
||||
static void setClipboardText(const std::string& s);
|
||||
|
||||
/**
|
||||
Tries to locate the resource by looking in related directories.
|
||||
If found, returns the full path to the resource, otherwise
|
||||
returns the empty string.
|
||||
*/
|
||||
static std::string findDataFile(const std::string& full, bool errorIfNotFound = true);
|
||||
|
||||
/**
|
||||
Sets the path that the application is using as its data directory.
|
||||
Used by findDataDir as an initial search location. GApp sets this
|
||||
upon constrution.
|
||||
*/
|
||||
static void setAppDataDir(const std::string& path);
|
||||
|
||||
private:
|
||||
/**
|
||||
(CKO) Note: Not sure why these are specifically needed
|
||||
for OS X. I made them private though.
|
||||
*/
|
||||
# ifdef G3D_OSX
|
||||
static long m_OSXCPUSpeed; //In Cycles/Second
|
||||
static double m_secondsPerNS;
|
||||
# endif
|
||||
};
|
||||
|
||||
|
||||
#ifdef _MSC_VER
|
||||
inline uint64 System::getCycleCount() {
|
||||
uint32 timehi, timelo;
|
||||
|
||||
// Use the assembly instruction rdtsc, which gets the current
|
||||
// cycle count (since the process started) and puts it in edx:eax.
|
||||
__asm
|
||||
{
|
||||
rdtsc;
|
||||
mov timehi, edx;
|
||||
mov timelo, eax;
|
||||
}
|
||||
|
||||
return ((uint64)timehi << 32) + (uint64)timelo;
|
||||
}
|
||||
|
||||
#elif defined(G3D_LINUX)
|
||||
|
||||
inline uint64 System::getCycleCount() {
|
||||
uint32 timehi, timelo;
|
||||
|
||||
__asm__ __volatile__ (
|
||||
"rdtsc "
|
||||
: "=a" (timelo),
|
||||
"=d" (timehi)
|
||||
: );
|
||||
|
||||
return ((uint64)timehi << 32) + (uint64)timelo;
|
||||
}
|
||||
|
||||
#elif defined(G3D_OSX)
|
||||
|
||||
inline uint64 System::getCycleCount() {
|
||||
//Note: To put off extra processing until the end, this does not
|
||||
//return the actual clock cycle count. It is a bus cycle count.
|
||||
//When endCycleCount() is called, it converts the two into a difference
|
||||
//of clock cycles
|
||||
|
||||
return (uint64) UnsignedWideToUInt64(UpTime());
|
||||
//return (uint64) mach_absolute_time();
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
inline void System::beginCycleCount(uint64& cycleCount) {
|
||||
cycleCount = getCycleCount();
|
||||
}
|
||||
|
||||
|
||||
inline void System::endCycleCount(uint64& cycleCount) {
|
||||
#ifndef G3D_OSX
|
||||
cycleCount = getCycleCount() - cycleCount;
|
||||
#else
|
||||
AbsoluteTime end = UpTime();
|
||||
init();
|
||||
Nanoseconds diffNS =
|
||||
AbsoluteDeltaToNanoseconds(end, UInt64ToUnsignedWide(cycleCount));
|
||||
cycleCount =
|
||||
(uint64) ((double) (System::m_OSXCPUSpeed) *
|
||||
(double) UnsignedWideToUInt64(diffNS) * m_secondsPerNS);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
+770
@@ -0,0 +1,770 @@
|
||||
/**
|
||||
@file Table.h
|
||||
|
||||
Templated hash table class.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2001-04-22
|
||||
@edited 2008-07-01
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_TABLE_H
|
||||
#define G3D_TABLE_H
|
||||
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/debug.h"
|
||||
#include "G3D/System.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/EqualsTrait.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (push)
|
||||
// Debug name too long warning
|
||||
# pragma warning (disable : 4786)
|
||||
#endif
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
An unordered data structure mapping keys to values.
|
||||
|
||||
Key must be a pointer, an int, a std::string or provide overloads for:
|
||||
|
||||
<PRE>
|
||||
template<> struct HashTrait<class Key> {
|
||||
static size_t hashCode(const Key& key) { return reinterpret_cast<size_t>( ... ); }
|
||||
};
|
||||
</PRE>
|
||||
|
||||
and one of
|
||||
|
||||
<PRE>
|
||||
template<> struct EqualsTrait<class Key>{
|
||||
static bool equals(const Key& a, const Key& b) { return ... ; }
|
||||
};
|
||||
|
||||
|
||||
bool operator==(const Key&, const Key&);
|
||||
</PRE>
|
||||
|
||||
G3D pre-defines HashTrait specializations for common types (like <CODE>int</CODE> and <CODE>std::string</CODE>).
|
||||
If you use a Table with a different type you must write those functions yourself. For example,
|
||||
an enum would use:
|
||||
|
||||
<PRE>
|
||||
template<> struct HashTrait<MyEnum> {
|
||||
static size_t equals(const MyEnum& key) const { return reinterpret_cast<size_t>( key ); }
|
||||
};
|
||||
</PRE>
|
||||
|
||||
And rely on the default enum operator==.
|
||||
|
||||
|
||||
Periodically check that debugGetLoad() is low (> 0.1). When it gets near
|
||||
1.0 your hash function is badly designed and maps too many inputs to
|
||||
the same output.
|
||||
*/
|
||||
template<class Key, class Value, class HashFunc = HashTrait<Key>, class EqualsFunc = EqualsTrait<Key> >
|
||||
class Table {
|
||||
public:
|
||||
|
||||
/**
|
||||
The pairs returned by iterator.
|
||||
*/
|
||||
class Entry {
|
||||
public:
|
||||
Key key;
|
||||
Value value;
|
||||
Entry() {}
|
||||
Entry(const Key& k, const Value& v) : key(k), value(v) {}
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
typedef Table<Key, Value, HashFunc, EqualsFunc> ThisType;
|
||||
|
||||
/**
|
||||
Linked list nodes used internally by HashTable.
|
||||
*/
|
||||
class Node {
|
||||
public:
|
||||
Entry entry;
|
||||
size_t hashCode;
|
||||
Node* next;
|
||||
|
||||
/** Provide pooled allocation for speed. */
|
||||
inline void* operator new (size_t size) {
|
||||
return System::malloc(size);
|
||||
}
|
||||
|
||||
inline void operator delete (void* p) {
|
||||
System::free(p);
|
||||
}
|
||||
|
||||
Node(const Key& k, const Value& v, size_t h, Node* n)
|
||||
: entry(k, v), hashCode(h), next(n) {
|
||||
}
|
||||
|
||||
/**
|
||||
Clones a whole chain;
|
||||
*/
|
||||
Node* clone() {
|
||||
return new Node(this->entry.key, this->entry.value, hashCode, (next == NULL) ? NULL : next->clone());
|
||||
}
|
||||
};
|
||||
|
||||
void checkIntegrity() const {
|
||||
# ifdef G3D_DEBUG
|
||||
debugAssert(bucket == NULL || isValidHeapPointer(bucket));
|
||||
for (size_t b = 0; b < numBuckets; ++b) {
|
||||
Node* node = bucket[b];
|
||||
debugAssert(node == NULL || isValidHeapPointer(node));
|
||||
while (node != NULL) {
|
||||
debugAssert(node == NULL || isValidHeapPointer(node));
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
# endif
|
||||
}
|
||||
|
||||
/**
|
||||
Number of elements in the table.
|
||||
*/
|
||||
size_t _size;
|
||||
|
||||
/**
|
||||
Array of Node*.
|
||||
We don't use Array<Node*> because Table is lower level.
|
||||
Some elements may be NULL.
|
||||
*/
|
||||
Node** bucket;
|
||||
|
||||
/**
|
||||
Length of the bucket array.
|
||||
*/
|
||||
size_t numBuckets;
|
||||
|
||||
/**
|
||||
Re-hashes for a larger bucket size.
|
||||
*/
|
||||
void resize(size_t newSize) {
|
||||
|
||||
// Hang onto the old bucket array
|
||||
Node** oldBucket = bucket;
|
||||
|
||||
// Allocate a new bucket array with the new size
|
||||
bucket = (Node**)System::calloc(sizeof(Node*), newSize);
|
||||
debugAssertM(bucket != NULL, "System::calloc returned NULL. Out of memory.");
|
||||
// Move each node to its new hash location
|
||||
for (size_t b = 0; b < numBuckets; ++b) {
|
||||
Node* node = oldBucket[b];
|
||||
|
||||
// There is a linked list of nodes at this bucket
|
||||
while (node != NULL) {
|
||||
// Hang onto the old next pointer
|
||||
Node* nextNode = node->next;
|
||||
|
||||
// Insert at the head of the list for bucket[i]
|
||||
size_t i = node->hashCode % newSize;
|
||||
node->next = bucket[i];
|
||||
bucket[i] = node;
|
||||
|
||||
// Move on to the next node
|
||||
node = nextNode;
|
||||
}
|
||||
|
||||
// Drop the old pointer for cleanliness when debugging
|
||||
oldBucket[b] = NULL;
|
||||
}
|
||||
|
||||
// Delete the old storage
|
||||
System::free(oldBucket);
|
||||
this->numBuckets = newSize;
|
||||
|
||||
checkIntegrity();
|
||||
}
|
||||
|
||||
|
||||
void copyFrom(const ThisType& h) {
|
||||
if (&h == this) {
|
||||
return;
|
||||
}
|
||||
|
||||
debugAssert(bucket == NULL);
|
||||
_size = h._size;
|
||||
numBuckets = h.numBuckets;
|
||||
bucket = (Node**)System::calloc(sizeof(Node*), numBuckets);
|
||||
|
||||
for (size_t b = 0; b < numBuckets; b++) {
|
||||
if (h.bucket[b] != NULL) {
|
||||
bucket[b] = h.bucket[b]->clone();
|
||||
}
|
||||
}
|
||||
|
||||
checkIntegrity();
|
||||
}
|
||||
|
||||
/**
|
||||
Frees the heap structures for the nodes.
|
||||
*/
|
||||
void freeMemory() {
|
||||
checkIntegrity();
|
||||
|
||||
for (size_t b = 0; b < numBuckets; b++) {
|
||||
Node* node = bucket[b];
|
||||
while (node != NULL) {
|
||||
Node* next = node->next;
|
||||
delete node;
|
||||
node = next;
|
||||
}
|
||||
bucket[b] = NULL;
|
||||
}
|
||||
System::free(bucket);
|
||||
bucket = NULL;
|
||||
numBuckets = 0;
|
||||
_size = 0;
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
Creates an empty hash table. This causes some heap allocation to occur.
|
||||
*/
|
||||
Table() : bucket(NULL) {
|
||||
numBuckets = 10;
|
||||
_size = 0;
|
||||
bucket = (Node**)System::calloc(sizeof(Node*), numBuckets);
|
||||
checkIntegrity();
|
||||
}
|
||||
|
||||
/**
|
||||
Recommends that the table resize to anticipate at least this number of elements.
|
||||
*/
|
||||
void setSizeHint(size_t n) {
|
||||
size_t s = n * 3;
|
||||
if (s > numBuckets) {
|
||||
resize(s);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Destroys all of the memory allocated by the table, but does <B>not</B>
|
||||
call delete on keys or values if they are pointers. If you want to
|
||||
deallocate things that the table points at, use getKeys() and Array::deleteAll()
|
||||
to delete them.
|
||||
*/
|
||||
virtual ~Table() {
|
||||
freeMemory();
|
||||
}
|
||||
|
||||
Table(const ThisType& h) {
|
||||
numBuckets = 0;
|
||||
_size = 0;
|
||||
bucket = NULL;
|
||||
this->copyFrom(h);
|
||||
checkIntegrity();
|
||||
}
|
||||
|
||||
|
||||
Table& operator=(const ThisType& h) {
|
||||
// No need to copy if the argument is this
|
||||
if (this != &h) {
|
||||
// Free the existing nodes
|
||||
freeMemory();
|
||||
this->copyFrom(h);
|
||||
checkIntegrity();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the length of the deepest bucket.
|
||||
*/
|
||||
size_t debugGetDeepestBucketSize() const {
|
||||
size_t deepest = 0;
|
||||
|
||||
for (size_t b = 0; b < numBuckets; b++) {
|
||||
size_t count = 0;
|
||||
Node* node = bucket[b];
|
||||
while (node != NULL) {
|
||||
node = node->next;
|
||||
++count;
|
||||
}
|
||||
|
||||
if (count > deepest) {
|
||||
deepest = count;
|
||||
}
|
||||
}
|
||||
|
||||
return deepest;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the average size of non-empty buckets.
|
||||
*/
|
||||
float debugGetAverageBucketSize() const {
|
||||
size_t num = 0;
|
||||
size_t count = 0;
|
||||
|
||||
for (size_t b = 0; b < numBuckets; b++) {
|
||||
Node* node = bucket[b];
|
||||
if (node != NULL) {
|
||||
++num;
|
||||
while (node != NULL) {
|
||||
node = node->next;
|
||||
++count;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (float)((double)count / num);
|
||||
}
|
||||
|
||||
/**
|
||||
A small load (close to zero) means the hash table is acting very
|
||||
efficiently most of the time. A large load (close to 1) means
|
||||
the hash table is acting poorly-- all operations will be very slow.
|
||||
A large load will result from a bad hash function that maps too
|
||||
many keys to the same code.
|
||||
*/
|
||||
double debugGetLoad() const {
|
||||
return debugGetDeepestBucketSize() / (double)size();
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the number of buckets.
|
||||
*/
|
||||
size_t debugGetNumBuckets() const {
|
||||
return numBuckets;
|
||||
}
|
||||
|
||||
/**
|
||||
C++ STL style iterator variable. See begin().
|
||||
*/
|
||||
class Iterator {
|
||||
private:
|
||||
friend class Table<Key, Value, HashFunc, EqualsFunc>;
|
||||
|
||||
/**
|
||||
Bucket index.
|
||||
*/
|
||||
size_t index;
|
||||
|
||||
/**
|
||||
Linked list node.
|
||||
*/
|
||||
Node* node;
|
||||
ThisType* table;
|
||||
size_t numBuckets;
|
||||
Node** bucket;
|
||||
bool isDone;
|
||||
|
||||
/**
|
||||
Creates the end iterator.
|
||||
*/
|
||||
Iterator(const ThisType* table) : table(const_cast<ThisType*>(table)) {
|
||||
isDone = true;
|
||||
}
|
||||
|
||||
Iterator(const ThisType* table, size_t numBuckets, Node** bucket) :
|
||||
table(const_cast<ThisType*>(table)),
|
||||
numBuckets(numBuckets),
|
||||
bucket(bucket) {
|
||||
|
||||
if (numBuckets == 0) {
|
||||
// Empty table
|
||||
isDone = true;
|
||||
return;
|
||||
}
|
||||
|
||||
index = 0;
|
||||
node = bucket[index];
|
||||
isDone = false;
|
||||
findNext();
|
||||
}
|
||||
|
||||
/**
|
||||
Finds the next element, setting isDone if one can't be found.
|
||||
Looks at the current element first.
|
||||
*/
|
||||
void findNext() {
|
||||
while (node == NULL) {
|
||||
index++;
|
||||
if (index >= numBuckets) {
|
||||
isDone = true;
|
||||
break;
|
||||
} else {
|
||||
node = bucket[index];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
inline bool operator!=(const Iterator& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
bool operator==(const Iterator& other) const {
|
||||
if (other.isDone || isDone) {
|
||||
// Common case; check against isDone.
|
||||
return (isDone == other.isDone) && (other.table == table);
|
||||
} else {
|
||||
return
|
||||
(table == other.table) &&
|
||||
(node == other.node) &&
|
||||
(index == other.index);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Pre increment.
|
||||
*/
|
||||
Iterator& operator++() {
|
||||
node = node->next;
|
||||
findNext();
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
Post increment (slower than preincrement).
|
||||
*/
|
||||
Iterator operator++(int) {
|
||||
Iterator old = *this;
|
||||
++(*this);
|
||||
return old;
|
||||
}
|
||||
|
||||
const Entry& operator*() const {
|
||||
return node->entry;
|
||||
}
|
||||
|
||||
Entry* operator->() const {
|
||||
return &(node->entry);
|
||||
}
|
||||
|
||||
operator Entry*() const {
|
||||
return &(node->entry);
|
||||
}
|
||||
|
||||
bool hasMore() const {
|
||||
return ! isDone;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
C++ STL style iterator method. Returns the first Entry, which
|
||||
contains a key and value. Use preincrement (++entry) to get to
|
||||
the next element. Do not modify the table while iterating.
|
||||
*/
|
||||
Iterator begin() const {
|
||||
return Iterator(this, numBuckets, bucket);
|
||||
}
|
||||
|
||||
/**
|
||||
C++ STL style iterator method. Returns one after the last iterator
|
||||
element.
|
||||
*/
|
||||
const Iterator end() const {
|
||||
return Iterator(this);
|
||||
}
|
||||
|
||||
/**
|
||||
Removes all elements
|
||||
*/
|
||||
void clear() {
|
||||
freeMemory();
|
||||
numBuckets = 10;
|
||||
_size = 0;
|
||||
bucket = (Node**)System::calloc(sizeof(Node*), numBuckets);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Returns the number of keys.
|
||||
*/
|
||||
size_t size() const {
|
||||
return _size;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
If you insert a pointer into the key or value of a table, you are
|
||||
responsible for deallocating the object eventually. Inserting
|
||||
key into a table is O(1), but may cause a potentially slow rehashing.
|
||||
*/
|
||||
void set(const Key& key, const Value& value) {
|
||||
size_t code = HashFunc::hashCode(key);
|
||||
size_t b = code % numBuckets;
|
||||
|
||||
// Go to the bucket
|
||||
Node* n = bucket[b];
|
||||
|
||||
// No bucket, so this must be the first
|
||||
if (n == NULL) {
|
||||
bucket[b] = new Node(key, value, code, NULL);
|
||||
++_size;
|
||||
return;
|
||||
}
|
||||
|
||||
size_t bucketLength = 1;
|
||||
|
||||
// Sometimes a bad hash code will cause all elements
|
||||
// to collide. Detect this case and don't rehash when
|
||||
// it occurs; nothing good will come from the rehashing.
|
||||
bool allSameCode = true;
|
||||
|
||||
// Try to find the node
|
||||
do {
|
||||
allSameCode = allSameCode && (code == n->hashCode);
|
||||
|
||||
if ((code == n->hashCode) && EqualsFunc::equals(n->entry.key, key)) {
|
||||
// Replace the existing node.
|
||||
n->entry.value = value;
|
||||
return;
|
||||
}
|
||||
|
||||
n = n->next;
|
||||
++bucketLength;
|
||||
} while (n != NULL);
|
||||
|
||||
const size_t maxBucketLength = 3;
|
||||
// (Don't bother changing the size of the table if all entries
|
||||
// have the same hashcode--they'll still collide)
|
||||
if ((bucketLength > maxBucketLength) &&
|
||||
! allSameCode &&
|
||||
(numBuckets < _size * 15)) {
|
||||
|
||||
// This bucket was really large; rehash if all elements
|
||||
// don't have the same hashcode the number of buckets is
|
||||
// reasonable.
|
||||
|
||||
// Back off the scale factor as the number of buckets gets
|
||||
// large
|
||||
float f = 3.0f;
|
||||
if (numBuckets > 1000000) {
|
||||
f = 1.5f;
|
||||
} else if (numBuckets > 100000) {
|
||||
f = 2.0f;
|
||||
}
|
||||
int newSize = iMax((int)(numBuckets * f) + 1, (int)(_size * f));
|
||||
resize(newSize);
|
||||
}
|
||||
|
||||
// Not found; insert at the head.
|
||||
b = code % numBuckets;
|
||||
bucket[b] = new Node(key, value, code, bucket[b]);
|
||||
++_size;
|
||||
}
|
||||
|
||||
/**
|
||||
Removes an element from the table if it is present.
|
||||
@return true if the element was found and removed, otherwise false
|
||||
*/
|
||||
bool remove(const Key& key) {
|
||||
|
||||
size_t code = HashFunc::hashCode(key);
|
||||
size_t b = code % numBuckets;
|
||||
|
||||
// Go to the bucket
|
||||
Node* n = bucket[b];
|
||||
|
||||
if (n == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
Node* previous = NULL;
|
||||
|
||||
// Try to find the node
|
||||
do {
|
||||
if ((code == n->hashCode) && EqualsFunc::equals(n->entry.key, key)) {
|
||||
// This is the node; remove it
|
||||
|
||||
// Replace the previous's next pointer
|
||||
if (previous == NULL) {
|
||||
bucket[b] = n->next;
|
||||
} else {
|
||||
previous->next = n->next;
|
||||
}
|
||||
|
||||
// Delete the node
|
||||
delete n;
|
||||
--_size;
|
||||
return true;
|
||||
}
|
||||
|
||||
previous = n;
|
||||
n = n->next;
|
||||
} while (n != NULL);
|
||||
|
||||
|
||||
return false;
|
||||
//alwaysAssertM(false, "Tried to remove a key that was not in the table.");
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the value associated with key.
|
||||
@deprecated Use get(key, val) or getPointer(key)
|
||||
*/
|
||||
Value& get(const Key& key) const {
|
||||
|
||||
size_t code = HashFunc::hashCode(key);
|
||||
size_t b = code % numBuckets;
|
||||
|
||||
Node* node = bucket[b];
|
||||
|
||||
while (node != NULL) {
|
||||
if ((node->hashCode == code) && EqualsFunc::equals(node->entry.key, key)) {
|
||||
return node->entry.value;
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
debugAssertM(false, "Key not found");
|
||||
// The next line is here just to make
|
||||
// a compiler warning go away.
|
||||
return node->entry.value;
|
||||
}
|
||||
|
||||
|
||||
/** Returns a pointer to the element if it exists, or NULL if it does not.
|
||||
Note that if your value type <i>is</i> a pointer, the return value is
|
||||
a pointer to a pointer. Do not remove the element while holding this
|
||||
pointer.
|
||||
|
||||
It is easy to accidentally mis-use this method. Consider making
|
||||
a Table<Value*> and using get(key, val) instead, which makes you manage
|
||||
the memory for the values yourself and is less likely to result in
|
||||
pointer errors.
|
||||
*/
|
||||
Value* getPointer(const Key& key) const {
|
||||
size_t code = HashFunc::hashCode(key);
|
||||
size_t b = code % numBuckets;
|
||||
|
||||
Node* node = bucket[b];
|
||||
|
||||
while (node != NULL) {
|
||||
if ((node->hashCode == code) && EqualsFunc::equals(node->entry.key, key)) {
|
||||
// found key
|
||||
return &(node->entry.value);
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
|
||||
// Failed to find key
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
If the key is present in the table, val is set to the associated value and returns true.
|
||||
If the key is not present, returns false.
|
||||
*/
|
||||
bool get(const Key& key, Value& val) const {
|
||||
Value* v = getPointer(key);
|
||||
if (v != NULL) {
|
||||
val = *v;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if key is in the table.
|
||||
*/
|
||||
bool containsKey(const Key& key) const {
|
||||
size_t code = HashFunc::hashCode(key);
|
||||
size_t b = code % numBuckets;
|
||||
|
||||
Node* node = bucket[b];
|
||||
|
||||
while (node != NULL) {
|
||||
if ((node->hashCode == code) && EqualsFunc::equals(node->entry.key, key)) {
|
||||
return true;
|
||||
}
|
||||
node = node->next;
|
||||
} while (node != NULL);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Short syntax for get.
|
||||
*/
|
||||
inline Value& operator[](const Key &key) const {
|
||||
return get(key);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Returns an array of all of the keys in the table.
|
||||
You can iterate over the keys to get the values.
|
||||
@deprecated
|
||||
*/
|
||||
Array<Key> getKeys() const {
|
||||
Array<Key> keyArray;
|
||||
getKeys(keyArray);
|
||||
return keyArray;
|
||||
}
|
||||
|
||||
void getKeys(Array<Key>& keyArray) const {
|
||||
keyArray.resize(0, DONT_SHRINK_UNDERLYING_ARRAY);
|
||||
for (size_t i = 0; i < numBuckets; i++) {
|
||||
Node* node = bucket[i];
|
||||
while (node != NULL) {
|
||||
keyArray.append(node->entry.key);
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Calls delete on all of the keys and then clears the table.
|
||||
*/
|
||||
void deleteKeys() {
|
||||
for (size_t i = 0; i < numBuckets; i++) {
|
||||
Node* node = bucket[i];
|
||||
while (node != NULL) {
|
||||
delete node->entry.key;
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
clear();
|
||||
}
|
||||
|
||||
/**
|
||||
Calls delete on all of the values. This is unsafe--
|
||||
do not call unless you know that each value appears
|
||||
at most once.
|
||||
|
||||
Does not clear the table, so you are left with a table
|
||||
of NULL pointers.
|
||||
*/
|
||||
void deleteValues() {
|
||||
for (size_t i = 0; i < numBuckets; ++i) {
|
||||
Node* node = bucket[i];
|
||||
while (node != NULL) {
|
||||
delete node->entry.value;
|
||||
node->entry.value = NULL;
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
+693
@@ -0,0 +1,693 @@
|
||||
/**
|
||||
@file TextInput.h
|
||||
|
||||
Simple text lexer/tokenizer.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@cite Based on a lexer written by Aaron Orenstein.
|
||||
|
||||
@created 2002-11-27
|
||||
@edited 2006-10-24
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_TEXTINPUT_H
|
||||
#define G3D_TEXTINPUT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Set.h"
|
||||
#include <string>
|
||||
#include <queue>
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
For use with TextInput.
|
||||
*/
|
||||
class Token {
|
||||
public:
|
||||
|
||||
/**
|
||||
More detailed type information than Type.
|
||||
*/
|
||||
enum ExtendedType {
|
||||
DOUBLE_QUOTED_TYPE,
|
||||
SINGLE_QUOTED_TYPE,
|
||||
SYMBOL_TYPE,
|
||||
FLOATING_POINT_TYPE,
|
||||
INTEGER_TYPE,
|
||||
BOOLEAN_TYPE,
|
||||
END_TYPE
|
||||
};
|
||||
|
||||
/**
|
||||
Strings are enclosed in quotes, symbols are not.
|
||||
*/
|
||||
enum Type {
|
||||
STRING = DOUBLE_QUOTED_TYPE,
|
||||
SYMBOL = SYMBOL_TYPE,
|
||||
NUMBER = FLOATING_POINT_TYPE,
|
||||
BOOLEAN = BOOLEAN_TYPE,
|
||||
END = END_TYPE
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
friend class TextInput;
|
||||
|
||||
/**
|
||||
Holds the actual value, which might be any type. If a number, it will be
|
||||
parsed at runtime.
|
||||
*/
|
||||
std::string _string;
|
||||
|
||||
bool _bool;
|
||||
int _line;
|
||||
int _character;
|
||||
Type _type;
|
||||
ExtendedType _extendedType;
|
||||
|
||||
public:
|
||||
|
||||
Token() :
|
||||
_string(""),
|
||||
_bool(false),
|
||||
_line(0),
|
||||
_character(0),
|
||||
_type(END),
|
||||
_extendedType(END_TYPE) {}
|
||||
|
||||
Token(Type t, ExtendedType e, const std::string& s, int L, int c)
|
||||
: _string(s), _bool(false), _line(L), _character(c), _type(t), _extendedType(e) {}
|
||||
|
||||
Token(Type t, ExtendedType e, const std::string& s, bool b, int L, int c)
|
||||
: _string(s), _bool(b), _line(L), _character(c), _type(t), _extendedType(e) {}
|
||||
|
||||
Type type() const {
|
||||
return _type;
|
||||
}
|
||||
|
||||
ExtendedType extendedType() const {
|
||||
return _extendedType;
|
||||
}
|
||||
|
||||
/**
|
||||
The value of a single or double quote string (not including the quotes),
|
||||
the name of a symbol, or the exact textual representation of a number as
|
||||
parsed from the input.
|
||||
*/
|
||||
const std::string& string() const {
|
||||
return _string;
|
||||
}
|
||||
|
||||
bool boolean() const {
|
||||
return _bool;
|
||||
}
|
||||
|
||||
/**
|
||||
Starting line of the input from which this token was parsed. Starts
|
||||
at 1.
|
||||
*/
|
||||
int line() const {
|
||||
return _line;
|
||||
}
|
||||
|
||||
/**
|
||||
Starting character position in the input line from which this token was
|
||||
parsed. Starts at 1.
|
||||
*/
|
||||
int character() const {
|
||||
return _character;
|
||||
}
|
||||
|
||||
/** Return the numeric value for a number type, or zero if this is
|
||||
not a number type.
|
||||
*/
|
||||
double number() const;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
A simple style tokenizer for reading text files. TextInput handles a
|
||||
superset of C++,Java, Matlab, and Bash code text including single
|
||||
line comments, block comments, quoted strings with escape sequences,
|
||||
and operators. TextInput recognizes several categories of tokens,
|
||||
which are separated by white space, quotation marks, or the end of a
|
||||
recognized operator:
|
||||
|
||||
<ul>
|
||||
<li><CODE>Token::SINGLE_QUOTED_TYPE</CODE> string of characters surrounded by single quotes, e.g., 'x', '\0', 'foo'.
|
||||
<li><CODE>Token::DOUBLE_QUOTED_TYPE</CODE> string of characters surrounded by double quotes, e.g., "x", "abc\txyz", "b o b".
|
||||
<li><CODE>Token::SYMBOL_TYPE</CODE> legal C++ operators, keywords, and identifiers. e.g., >=, Foo, _X, class, {
|
||||
<li><CODE>Token::INTEGER_TYPE</CODE> numbers without decimal places or exponential notation. e.g., 10, 0x17F, 32, 0, -155
|
||||
<li><CODE>Token::FLOATING_POINT_TYPE</CODE> numbers with decimal places or exponential notation. e.g., 1e3, -1.2, .4, 0.5
|
||||
<li><CODE>Token::BOOLEAN_TYPE</CODE> special symbols like "true" and "false"; the exact details can be configured in TextInput::Settings
|
||||
</ul>
|
||||
|
||||
<P>The special ".." and "..." tokens are always recognized in
|
||||
addition to normal C++ operators. Additional tokens can be made
|
||||
available by changing the Settings.
|
||||
|
||||
Negative numbers are handled specially because of the ambiguity between unary minus and negative numbers--
|
||||
see the note on TextInput::read.
|
||||
|
||||
TextInput does not have helper functions for types with non-obvious
|
||||
formatting, or helpers that would be redundant. Use the serialize
|
||||
methods instead for parsing specific types like int, Vector3, and
|
||||
Color3.
|
||||
|
||||
Inside quoted strings escape sequences are converted. Thus the
|
||||
string token for ["a\nb"] is 'a', followed by a newline, followed by
|
||||
'b'. Outside of quoted strings, escape sequences are not converted,
|
||||
so the token sequence for [a\nb] is symbol 'a', symbol '\', symbol
|
||||
'nb' (this matches what a C++ parser would do). The exception is
|
||||
that a specified TextInput::Settings::otherCommentCharacter preceeded
|
||||
by a backslash is assumed to be an escaped comment character and is
|
||||
returned as a symbol token instead of being parsed as a comment
|
||||
(this is what a LaTex or VRML parser would do).
|
||||
|
||||
<B>Examples</B>
|
||||
|
||||
<PRE>
|
||||
TextInput ti(TextInput::FROM_STRING, "name = \"Max\", height = 6");
|
||||
|
||||
Token t;
|
||||
|
||||
t = ti.read();
|
||||
debugAssert(t.type == Token::SYMBOL);
|
||||
debugAssert(t.sval == "name");
|
||||
|
||||
ti.read();
|
||||
debugAssert(t.type == Token::SYMBOL);
|
||||
debugAssert(t.sval == "=");
|
||||
|
||||
std::string name = ti.read().sval;
|
||||
ti.read();
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
TextInput ti(TextInput::FROM_STRING, "name = \"Max\", height = 6");
|
||||
ti.readSymbols("name", "=");
|
||||
std::string name = ti.readString();
|
||||
ti.readSymbols(",", "height", "=");
|
||||
double height = ti. readNumber();
|
||||
</PRE>
|
||||
|
||||
Assumes that the file is not modified once opened.
|
||||
*/
|
||||
class TextInput {
|
||||
public:
|
||||
|
||||
/** Tokenizer configuration options. */
|
||||
class Settings {
|
||||
public:
|
||||
/** If true, slash-star marks a multi-line comment. Default
|
||||
is true. */
|
||||
bool cComments;
|
||||
|
||||
/** If true, // begins a single line comment. Default is true. */
|
||||
bool cppComments;
|
||||
|
||||
/** If true, \r, \n, \t, \0, \\ and other escape sequences inside
|
||||
strings are converted to the equivalent C++ escaped character.
|
||||
If false, backslashes are treated literally. It is convenient to
|
||||
set to false if reading Windows paths, for example, like
|
||||
c:\foo\bar.
|
||||
|
||||
Default is true.
|
||||
*/
|
||||
bool escapeSequencesInStrings;
|
||||
|
||||
/** If non-NUL, specifies a character that begins single line
|
||||
comments ('#' and '%' are popular choices). This is independent
|
||||
of the cppComments flag. If the character appears in text with a
|
||||
backslash in front of it, it is considered escaped and is not
|
||||
treated as a comment character.
|
||||
|
||||
Default is '\0'.
|
||||
*/
|
||||
char otherCommentCharacter;
|
||||
|
||||
/** Another (optional) 1-comment character. Useful for files that
|
||||
support multiple comment syntaxes. Default is '\0'.
|
||||
*/
|
||||
char otherCommentCharacter2;
|
||||
|
||||
/** If true, "-1" parses as the number -1 instead of the
|
||||
symbol "-" followed by the number 1. Default is true.*/
|
||||
bool signedNumbers;
|
||||
|
||||
/** If true, strings can be marked with single quotes (e.g.,
|
||||
'aaa'). If false, the quote character is parsed as a
|
||||
symbol. Default is true. Backquote (`) is always parsed
|
||||
as a symbol. */
|
||||
bool singleQuotedStrings;
|
||||
|
||||
/** If set to a non-empty string, that string will be used in
|
||||
place of the real file name (or in place of a pseudonym
|
||||
constructed from the buffer if given FROM_STRING) in
|
||||
tokens and exceptions.
|
||||
|
||||
Default is empty.
|
||||
*/
|
||||
std::string sourceFileName;
|
||||
|
||||
|
||||
/** Added to the line number reported by peekLineNumber and in
|
||||
exceptions. Useful for concatenating files that are
|
||||
parsed separately. Default is zero. */
|
||||
int startingLineNumberOffset;
|
||||
|
||||
/**
|
||||
Parse -1.#IND00 as the floating point number returned by
|
||||
nan(), -1.#INF00 as -inf(), and 1.#INF00 as inf(). Note
|
||||
that the C99 standard specifies that a variety of formats
|
||||
like "NaN" and "nan" are to be used; these are easier to
|
||||
parse yourself and not currently supported by readNumber.
|
||||
|
||||
An alternative to specifying msvcSpecials is to read numbers as:
|
||||
<pre>
|
||||
Token x = t.read();
|
||||
Token y = t.peek();
|
||||
if ((x.string() == "-1.") &&
|
||||
(y.string() == "#INF00") &&
|
||||
(y.character() == x.character() + 3) &&
|
||||
(y.line() == x.line()) {
|
||||
t.read();
|
||||
return nan();
|
||||
}
|
||||
// ... similar cases for inf
|
||||
</pre>
|
||||
|
||||
If the single-comment character was #, the floating point
|
||||
special format overrides the comment and will be parsed
|
||||
instead.
|
||||
|
||||
If signedNumbers is false msvcSpecials will not be parsed.
|
||||
|
||||
Default is true. */
|
||||
bool msvcSpecials;
|
||||
|
||||
/**
|
||||
Parse the following set of useful proof symbols:
|
||||
|
||||
=>
|
||||
::>
|
||||
<::
|
||||
:>
|
||||
<:
|
||||
|-
|
||||
::=
|
||||
:=
|
||||
<-
|
||||
|
||||
Default is false.
|
||||
*/
|
||||
bool proofSymbols;
|
||||
|
||||
/**
|
||||
When parsing booleans and msvcSpecials, is case significant?
|
||||
Default is {true}
|
||||
*/
|
||||
bool caseSensitive;
|
||||
|
||||
/** All symbols that will become the 'true' boolean token. See also caseSensitive.
|
||||
Clear this value to disable parsing of true booleans.
|
||||
|
||||
Default is {true}.
|
||||
*/
|
||||
Set<std::string> trueSymbols;
|
||||
|
||||
/** See trueSymbols. Default is {false}*/
|
||||
Set<std::string> falseSymbols;
|
||||
|
||||
Settings ();
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
std::deque<Token> stack;
|
||||
|
||||
/**
|
||||
Characters to be tokenized.
|
||||
*/
|
||||
Array<char> buffer;
|
||||
|
||||
/**
|
||||
Offset of current character (the next character to consumed) in
|
||||
input buffer.
|
||||
*/
|
||||
unsigned int currentCharOffset;
|
||||
|
||||
/**
|
||||
Line number of next character to be consumed from the input buffer. (1
|
||||
indicates first line of input.)
|
||||
|
||||
Note that this is the line number of the @e next character to be
|
||||
consumed from the input, not the line number of the @e last character
|
||||
consumed!
|
||||
*/
|
||||
unsigned int lineNumber;
|
||||
|
||||
/**
|
||||
Character number (within the line) of the next character to be consumed
|
||||
from the input buffer. (1 indicates first character of the line).
|
||||
|
||||
Note that this is the character number of the @e next character to be
|
||||
consumed from the input, not the character number of the @e last
|
||||
character consumed!
|
||||
*/
|
||||
unsigned int charNumber;
|
||||
|
||||
/** Configuration options. This includes the file name that will be
|
||||
reported in tokens and exceptions. */
|
||||
Settings options;
|
||||
|
||||
void init();
|
||||
|
||||
/**
|
||||
Consumes the next character from the input buffer, and returns that
|
||||
character. Updates lineNumber and charNumber to reflect the location of
|
||||
the next character in the input buffer.
|
||||
|
||||
Note: you shouldn't be using the return value of this function in most
|
||||
cases. In general, you should peekInputChar() to get the next
|
||||
character, determine what to do with it, then consume it with this
|
||||
function (or with eatAndPeekInputChar()). Given that usage, in most
|
||||
instances you already know what this function would return!
|
||||
*/
|
||||
int eatInputChar();
|
||||
|
||||
/**
|
||||
Returns the next character from the input buffer, without consuming any
|
||||
characters. Can also be used to look deeper into the input buffer.
|
||||
Does not modify lineNumber or charNumber.
|
||||
|
||||
@param distance Index of the character in the input buffer to peek at,
|
||||
relative to the next character. Default is 0, for the next character in
|
||||
the input buffer.
|
||||
*/
|
||||
int peekInputChar(unsigned int distance = 0);
|
||||
|
||||
/**
|
||||
Helper function to consume the next character in the input buffer and
|
||||
peek at the one following (without consuming it).
|
||||
*/
|
||||
inline int eatAndPeekInputChar() {
|
||||
eatInputChar();
|
||||
return peekInputChar(0);
|
||||
}
|
||||
|
||||
/**
|
||||
Read the next token, returning an END token if no more input is
|
||||
available.
|
||||
*/
|
||||
Token nextToken();
|
||||
|
||||
/**
|
||||
Helper for nextToken. Appends characters to t._string until the end
|
||||
delimiter is reached.
|
||||
|
||||
When called, the next character in the input buffer should be first the
|
||||
first character after the opening delimiter character.
|
||||
*/
|
||||
void parseQuotedString(unsigned char delimiter, Token& t);
|
||||
|
||||
public:
|
||||
|
||||
class TokenException {
|
||||
public:
|
||||
/** Name of file being parsed when exception occurred. */
|
||||
std::string sourceFile;
|
||||
|
||||
/** Line number of start of token which caused the exception. 1 is
|
||||
the first line of the file. Note that you can use
|
||||
TextInput::Settings::startingLineNumberOffset to shift the effective line
|
||||
number that is reported.
|
||||
*/
|
||||
int line;
|
||||
|
||||
/** Character number in the line of start of token which caused the
|
||||
exception. 1 is the character in the line.
|
||||
*/
|
||||
int character;
|
||||
|
||||
/** Pre-formatted error message */
|
||||
std::string message;
|
||||
|
||||
virtual ~TokenException() {}
|
||||
|
||||
protected:
|
||||
|
||||
TokenException(
|
||||
const std::string& src,
|
||||
int ln,
|
||||
int ch);
|
||||
|
||||
};
|
||||
|
||||
/** While parsing a number of the form 1.#IN?00, ? was
|
||||
not 'D' or 'F'. */
|
||||
class BadMSVCSpecial : public TokenException {
|
||||
public:
|
||||
|
||||
BadMSVCSpecial(
|
||||
const std::string& src,
|
||||
int ln,
|
||||
int ch);
|
||||
};
|
||||
|
||||
/** Thrown by the read methods. */
|
||||
class WrongTokenType : public TokenException {
|
||||
public:
|
||||
Token::Type expected;
|
||||
Token::Type actual;
|
||||
|
||||
WrongTokenType(
|
||||
const std::string& src,
|
||||
int ln,
|
||||
int ch,
|
||||
Token::Type e,
|
||||
Token::Type a);
|
||||
};
|
||||
|
||||
class WrongSymbol : public TokenException {
|
||||
public:
|
||||
std::string expected;
|
||||
std::string actual;
|
||||
|
||||
WrongSymbol(
|
||||
const std::string& src,
|
||||
int ln,
|
||||
int ch,
|
||||
const std::string& e,
|
||||
const std::string& a);
|
||||
};
|
||||
|
||||
|
||||
/** String read from input did not match expected string. */
|
||||
class WrongString : public TokenException {
|
||||
public:
|
||||
std::string expected;
|
||||
std::string actual;
|
||||
|
||||
WrongString(
|
||||
const std::string& src,
|
||||
int ln,
|
||||
int ch,
|
||||
const std::string& e,
|
||||
const std::string& a);
|
||||
};
|
||||
|
||||
TextInput(const std::string& filename, const Settings& settings = Settings());
|
||||
|
||||
enum FS {FROM_STRING};
|
||||
/** Creates input directly from a string. The first argument must be
|
||||
TextInput::FROM_STRING.
|
||||
*/
|
||||
TextInput(FS fs, const std::string& str, const Settings& settings = Settings());
|
||||
|
||||
/** Returns true while there are tokens remaining. */
|
||||
bool hasMore();
|
||||
|
||||
/** Read the next token (which will be the END token if ! hasMore()).
|
||||
|
||||
Signed numbers can be handled in one of two modes. If the option
|
||||
TextInput::Settings::signedNumbers is true,
|
||||
A '+' or '-' immediately before a number is prepended onto that number and
|
||||
if there is intervening whitespace, it is read as a separate symbol.
|
||||
|
||||
If TextInput::Settings::signedNumbers is false,
|
||||
read() does not distinguish between a plus or minus symbol next
|
||||
to a number and a positive/negative number itself. For example, "x - 1" and "x -1"
|
||||
will be parsed the same way by read().
|
||||
|
||||
In both cases, readNumber() will contract a leading "-" or "+" onto
|
||||
a number.
|
||||
*/
|
||||
Token read();
|
||||
|
||||
|
||||
/** Read one token (or possibly two) as a number or throws
|
||||
WrongTokenType, and returns the number.
|
||||
|
||||
If the first token in the input is a number, it is returned directly.
|
||||
|
||||
If TextInput::Settings::signedNumbers is false and the input stream
|
||||
contains a '+' or '-' symbol token immediately followed by a number
|
||||
token, both tokens will be consumed and a single token will be
|
||||
returned by this method.
|
||||
|
||||
WrongTokenType will be thrown if one of the input conditions
|
||||
described above is not satisfied. When an exception is thrown, no
|
||||
tokens are consumed.
|
||||
*/
|
||||
double readNumber();
|
||||
|
||||
bool readBoolean();
|
||||
|
||||
/** Reads a string token or throws WrongTokenType, and returns the token.
|
||||
|
||||
Use this method (rather than readString) if you want the token's
|
||||
location as well as its value.
|
||||
|
||||
WrongTokenType will be thrown if the next token in the input stream
|
||||
is not a string. When an exception is thrown, no tokens are
|
||||
consumed.
|
||||
*/
|
||||
Token readStringToken();
|
||||
|
||||
/** Like readStringToken, but returns the token's string.
|
||||
|
||||
Use this method (rather than readStringToken) if you want the token's
|
||||
value but don't really care about its location in the input. Use of
|
||||
readStringToken is encouraged for better error reporting.
|
||||
*/
|
||||
std::string readString();
|
||||
|
||||
/** Reads a specific string token or throws either WrongTokenType or
|
||||
WrongString. If the next token in the input is a string matching @p
|
||||
s, it will be consumed.
|
||||
|
||||
Use this method if you want to match a specific string from the
|
||||
input. In that case, typically error reporting related to the token
|
||||
is only going to occur because of a mismatch, so no location
|
||||
information is needed by the caller.
|
||||
|
||||
WrongTokenType will be thrown if the next token in the input stream
|
||||
is not a string. WrongString will be thrown if the next token in the
|
||||
input stream is a string but does not match the @p s parameter. When
|
||||
an exception is thrown, no tokens are consumed.
|
||||
*/
|
||||
void readString(const std::string& s);
|
||||
|
||||
|
||||
/** Reads a symbol token or throws WrongTokenType, and returns the token.
|
||||
|
||||
Use this method (rather than readSymbol) if you want the token's
|
||||
location as well as its value.
|
||||
|
||||
WrongTokenType will be thrown if the next token in the input stream
|
||||
is not a symbol. When an exception is thrown, no tokens are
|
||||
consumed.
|
||||
*/
|
||||
Token readSymbolToken();
|
||||
|
||||
/** Like readSymbolToken, but returns the token's string.
|
||||
|
||||
Use this method (rather than readSymbolToken) if you want the token's
|
||||
value but don't really care about its location in the input. Use of
|
||||
readSymbolToken is encouraged for better error reporting.
|
||||
*/
|
||||
std::string readSymbol();
|
||||
|
||||
/** Reads a specific symbol token or throws either WrongTokenType or
|
||||
WrongSymbol. If the next token in the input is a symbol matching @p
|
||||
symbol, it will be consumed.
|
||||
|
||||
Use this method if you want to match a specific symbol from the
|
||||
input. In that case, typically error reporting related to the token
|
||||
is only going to occur because of a mismatch, so no location
|
||||
information is needed by the caller.
|
||||
|
||||
WrongTokenType will be thrown if the next token in the input stream
|
||||
is not a symbol. WrongSymbol will be thrown if the next token in the
|
||||
input stream is a symbol but does not match the @p symbol parameter.
|
||||
When an exception is thrown, no tokens are consumed.
|
||||
*/
|
||||
void readSymbol(const std::string& symbol);
|
||||
|
||||
|
||||
/** Read a series of two specific symbols. See readSymbol. */
|
||||
inline void readSymbols(const std::string& s1, const std::string& s2) {
|
||||
readSymbol(s1);
|
||||
readSymbol(s2);
|
||||
}
|
||||
|
||||
/** Read a series of three specific symbols. See readSymbol. */
|
||||
inline void readSymbols(
|
||||
const std::string& s1,
|
||||
const std::string& s2,
|
||||
const std::string& s3) {
|
||||
readSymbol(s1);
|
||||
readSymbol(s2);
|
||||
readSymbol(s3);
|
||||
}
|
||||
|
||||
/** Read a series of four specific symbols. See readSymbol. */
|
||||
inline void readSymbols(
|
||||
const std::string& s1,
|
||||
const std::string& s2,
|
||||
const std::string& s3,
|
||||
const std::string& s4) {
|
||||
readSymbol(s1);
|
||||
readSymbol(s2);
|
||||
readSymbol(s3);
|
||||
readSymbol(s4);
|
||||
}
|
||||
|
||||
/** Return a copy of the next token in the input stream, but don't remove
|
||||
it from the input stream.
|
||||
*/
|
||||
Token peek();
|
||||
|
||||
/** Returns the line number for the @e next token. See also peek. */
|
||||
int peekLineNumber();
|
||||
|
||||
/** Returns the character number (relative to the line) for the @e next
|
||||
token in the input stream. See also peek.
|
||||
*/
|
||||
int peekCharacterNumber();
|
||||
|
||||
/** Take a previously read token and push it back at the front of the
|
||||
input stream.
|
||||
|
||||
Can be used in the case where more than one token of read-ahead is
|
||||
needed (i.e., when peek doesn't suffice).
|
||||
*/
|
||||
void push(const Token& t);
|
||||
|
||||
/** Returns the filename from which this input is drawn, or the first few
|
||||
characters of the string if created from a string.
|
||||
If options::filename is non-empty that will replace the
|
||||
true filename.*/
|
||||
const std::string& filename() const;
|
||||
};
|
||||
|
||||
void deserialize(bool& b, TextInput& ti);
|
||||
void deserialize(int& b, TextInput& ti);
|
||||
void deserialize(uint8& b, TextInput& ti);
|
||||
void deserialize(double& b, TextInput& ti);
|
||||
void deserialize(float& b, TextInput& ti);
|
||||
void deserialize(std::string& b, TextInput& ti);
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
|
||||
+249
@@ -0,0 +1,249 @@
|
||||
/**
|
||||
@file TextOutput.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
@created 2004-06-21
|
||||
@edited 2006-10-24
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_TEXTOUTPUT_H
|
||||
#define G3D_TEXTOUTPUT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Convenient formatting of ASCII text written to a file.
|
||||
<P>
|
||||
|
||||
The core writeString, writeNumber, and writeSymbol methods map to TextInput's
|
||||
methods. Number and Symbol each print an additional space that is used to
|
||||
separate adjacent tokens.
|
||||
|
||||
TextOutput::printf allows arbitrary text to be conveniently dumped
|
||||
en-masse. Use [de]serialize(bool, TextOutput) and other overloads to read/write
|
||||
primitive types in a standardized manner and
|
||||
|
||||
<P>
|
||||
When a word-wrap line break occurs, all whitespace between words is replaced
|
||||
with a single newline (the newline may be two characters-- see
|
||||
G3D::TextOutput::Options::NewlineStyle). Word wrapping occurs against
|
||||
the number of columns specified by Options::numColumns, <I>minus</I> the current
|
||||
indent level.
|
||||
|
||||
Indenting adds the specified number of spaces immediately after a newline.
|
||||
If a newline was followed by spaces in the original string, these are added
|
||||
to the indent spaces. Indenting <B>will</B> indent blank lines and will leave
|
||||
indents after the last newline of a file (if the indent level is non-zero at the end).
|
||||
|
||||
<P><B>Serialization/Marshalling</B>
|
||||
<DT>Text serialization is accomplished using TextOutput by defining the pair of
|
||||
methods:
|
||||
|
||||
<PRE>
|
||||
void serialize(TextOutput& to) const;
|
||||
void deserialize(TextInput& ti);
|
||||
</PRE>
|
||||
|
||||
See also G3D::TextInput.
|
||||
|
||||
<P>
|
||||
<B>BETA API</B>
|
||||
<DT>This API is subject to change in future versions.
|
||||
*/
|
||||
class TextOutput {
|
||||
public:
|
||||
|
||||
class Settings {
|
||||
public:
|
||||
/**
|
||||
WRAP_NONE Word wrapping is disabled
|
||||
WRAP_WITHOUT_BREAKING Word-wrap, but don't break continuous lines that
|
||||
are longer than numColumns (default)
|
||||
WRAP_ALWAYS Wrap even if it means breaking a continuous line or
|
||||
a quoted string.
|
||||
|
||||
Word wrapping is only allowed at whitespaces ('\n', '\r', '\t', ' '); it
|
||||
will not occur after commas, punctuation, minus signs, or any other characters
|
||||
*/
|
||||
enum WordWrapMode {WRAP_NONE, WRAP_WITHOUT_BREAKING, WRAP_ALWAYS};
|
||||
|
||||
/** Defaults to WRAP_WITHOUT_BREAKING */
|
||||
WordWrapMode wordWrap;
|
||||
|
||||
/** Is word-wrapping allowed to insert newlines inside double quotes?
|
||||
Default: false */
|
||||
bool allowWordWrapInsideDoubleQuotes;
|
||||
|
||||
/** Number of columns for word wrapping. Default: 8 */
|
||||
int numColumns;
|
||||
|
||||
/** Number of spaces in each indent. Default: 4 */
|
||||
int spacesPerIndent;
|
||||
|
||||
/** Style of newline used by word wrapping and by (optional) conversion.
|
||||
default: Windows: NEWLINE_WINDOWS, Linux, OS X: NEWLINE_UNIX.
|
||||
*/
|
||||
enum NewlineStyle {NEWLINE_WINDOWS, NEWLINE_UNIX};
|
||||
|
||||
NewlineStyle newlineStyle;
|
||||
|
||||
/** If true, all newlines are converted to NewlineStyle regardless of
|
||||
how they start out. Default: true. */
|
||||
bool convertNewlines;
|
||||
|
||||
/** Used by writeBoolean */
|
||||
std::string trueSymbol;
|
||||
|
||||
/** Used by writeBoolean */
|
||||
std::string falseSymbol;
|
||||
|
||||
Settings() :
|
||||
wordWrap(WRAP_WITHOUT_BREAKING),
|
||||
allowWordWrapInsideDoubleQuotes(false),
|
||||
numColumns(80),
|
||||
spacesPerIndent(4),
|
||||
convertNewlines(true),
|
||||
trueSymbol("true"),
|
||||
falseSymbol("false") {
|
||||
#ifdef G3D_WIN32
|
||||
newlineStyle = NEWLINE_WINDOWS;
|
||||
#else
|
||||
newlineStyle = NEWLINE_UNIX;
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
/** Used by indentAndAppend to tell when we are writing the
|
||||
first character of a new line.
|
||||
|
||||
So that push/popIndent work correctly, we cannot indent
|
||||
immediately after writing a newline. Instead we must
|
||||
indent on writing the first character <B>after</B> that
|
||||
newline.
|
||||
*/
|
||||
bool startingNewLine;
|
||||
|
||||
/** Number of characters at the end of the buffer since the last newline */
|
||||
int currentColumn;
|
||||
|
||||
/** True if we have seen an open " and no close ".*/
|
||||
bool inDQuote;
|
||||
|
||||
/** Empty if there is none */
|
||||
std::string filename;
|
||||
|
||||
Array<char> data;
|
||||
|
||||
Settings option;
|
||||
|
||||
/** Number of indents to prepend before each line. Always set using setIndentLevel.*/
|
||||
int indentLevel;
|
||||
|
||||
void setIndentLevel(int i);
|
||||
|
||||
/** Actual number of spaces to indent. */
|
||||
int indentSpaces;
|
||||
|
||||
/** the newline character(s) */
|
||||
std::string newline;
|
||||
|
||||
void setOptions(const Settings& _opt);
|
||||
|
||||
/** Converts to the desired newlines. Called from vprintf */
|
||||
void convertNewlines(const std::string& in, std::string& out);
|
||||
|
||||
/** Called from vprintf */
|
||||
void wordWrapIndentAppend(const std::string& str);
|
||||
|
||||
/** Appends the character to data, indenting whenever a newline is encountered.
|
||||
Called from wordWrapIndentAppend */
|
||||
void indentAppend(char c);
|
||||
|
||||
public:
|
||||
|
||||
explicit TextOutput(const std::string& filename, const Settings& options = Settings());
|
||||
|
||||
/** Constructs a text output that can later be commited to a string instead of a file.*/
|
||||
explicit TextOutput(const Settings& options = Settings());
|
||||
|
||||
/** Commit to the filename specified on the constructor.
|
||||
<B>Not</B> called from the destructor; you must call
|
||||
it yourself.
|
||||
@param flush If true (default) the file is ready for reading when the method returns, otherwise
|
||||
the method returns immediately and writes the file in the background.*/
|
||||
void commit(bool flush = true);
|
||||
|
||||
/** Commits to this string */
|
||||
void commitString(std::string& string);
|
||||
|
||||
/** Increase indent level by 1 */
|
||||
void pushIndent();
|
||||
|
||||
void popIndent();
|
||||
|
||||
/** Produces a new string that contains the output */
|
||||
std::string commitString();
|
||||
|
||||
/** Writes a quoted string. Special characters in the string (e.g., \, \t, \n) are escaped so that
|
||||
TextInput will produce the identical string on reading.*/
|
||||
void writeString(const std::string& string);
|
||||
|
||||
void writeBoolean(bool b);
|
||||
|
||||
void writeNumber(double n);
|
||||
|
||||
void writeNumber(int n);
|
||||
|
||||
void writeNewline();
|
||||
void writeNewlines(int numLines);
|
||||
|
||||
/** The symbol is written without quotes. Symbols are required to begin with a
|
||||
letter or underscore and contain only letters, underscores, and numbers
|
||||
or be a C++ symbol (e.g. "{", "(", "++", etc.)
|
||||
so that they may be properly parsed by TextInput::readSymbol. Symbols are
|
||||
printed with a trailing space.*/
|
||||
void writeSymbol(const std::string& string);
|
||||
|
||||
/** Convenient idiom for writing multiple symbols in a row, e.g.
|
||||
writeSymbols("name", "="); The empty symbols are not written.
|
||||
*/
|
||||
void writeSymbols(
|
||||
const std::string& a,
|
||||
const std::string& b = "",
|
||||
const std::string& c = "",
|
||||
const std::string& d = "",
|
||||
const std::string& e = "",
|
||||
const std::string& f = "");
|
||||
|
||||
/** Normal printf conventions. Note that the output will be reformatted
|
||||
for word-wrapping and newlines */
|
||||
void __cdecl printf(const char* fmt, ...)
|
||||
G3D_CHECK_PRINTF_METHOD_ARGS;
|
||||
|
||||
// Can't pass by reference because that confuses va_start
|
||||
void __cdecl printf(const std::string fmt, ...);
|
||||
void __cdecl vprintf(const char* fmt, va_list argPtr)
|
||||
G3D_CHECK_VPRINTF_METHOD_ARGS;
|
||||
};
|
||||
|
||||
// Primitive serializers
|
||||
void serialize(const bool& b, TextOutput& to);
|
||||
void serialize(const int& b, TextOutput& to);
|
||||
void serialize(const uint8& b, TextOutput& to);
|
||||
void serialize(const double& b, TextOutput& to);
|
||||
void serialize(const float& b, TextOutput& to);
|
||||
void serialize(const std::string& b, TextOutput& to);
|
||||
void serialize(const char* b, TextOutput& to);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,79 @@
|
||||
#ifndef G3D_THREADSET_H
|
||||
#define G3D_THREADSET_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/ReferenceCount.h"
|
||||
#include "G3D/GThread.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/** Manages a set of threads. All methods are threadsafe except for
|
||||
the iterator begin/end.
|
||||
|
||||
@beta*/
|
||||
class ThreadSet : public ReferenceCountedObject {
|
||||
public:
|
||||
/** Intended to allow future use with a template parameter.*/
|
||||
typedef GThread Thread;
|
||||
|
||||
typedef ReferenceCountedPointer<Thread> ThreadRef;
|
||||
typedef ReferenceCountedPointer<ThreadSet> Ref;
|
||||
typedef Array<ThreadRef>::Iterator Iterator;
|
||||
typedef Array<ThreadRef>::ConstIterator ConstIterator;
|
||||
|
||||
private:
|
||||
|
||||
/** Protects m_thread */
|
||||
GMutex m_lock;
|
||||
|
||||
/** Threads in the set */
|
||||
Array<ThreadRef> m_thread;
|
||||
|
||||
public:
|
||||
|
||||
/** Total number of threads (some of which may be completed). */
|
||||
int size() const;
|
||||
|
||||
/** Number of threads that have been started */
|
||||
int numStarted() const;
|
||||
|
||||
/** Start all threads that are not currently started */
|
||||
void start() const;
|
||||
|
||||
/** Terminate all threads that are currently started */
|
||||
void terminate() const;
|
||||
|
||||
/** Waits until all started threads have completed. */
|
||||
void waitForCompletion() const;
|
||||
|
||||
/** Remove all (not stopping them) */
|
||||
void clear();
|
||||
|
||||
/** Removes completed threads and returns the new size.*/
|
||||
int removeCompleted();
|
||||
|
||||
/** Inserts a new thread, if it is not already present, and
|
||||
returns the new number of threads.*/
|
||||
int insert(const ThreadRef& t);
|
||||
|
||||
/** Removes a thread. Returns true if the thread was present and
|
||||
removed. */
|
||||
bool remove(const ThreadRef& t);
|
||||
|
||||
bool contains(const ThreadRef& t) const;
|
||||
|
||||
/** It is an error to mutate the ThreadSet while iterating through it. */
|
||||
Iterator begin();
|
||||
|
||||
Iterator end();
|
||||
|
||||
ConstIterator begin() const;
|
||||
|
||||
ConstIterator end() const;
|
||||
};
|
||||
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
#endif
|
||||
+143
@@ -0,0 +1,143 @@
|
||||
/**
|
||||
@file Triangle.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-04-05
|
||||
@edited 2008-10-06
|
||||
|
||||
@cite Random point method by Greg Turk, Generating random points in triangles. In A. S. Glassner, ed., Graphics Gems, pp. 24-28. Academic Press, 1990
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_TRIANGLE_H
|
||||
#define G3D_TRIANGLE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Plane.h"
|
||||
#include "G3D/BoundsTrait.h"
|
||||
#include "G3D/debugAssert.h"
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A generic triangle representation. This should not be used
|
||||
as the underlying triangle for creating models; it is intended
|
||||
for providing fast property queries but requires a lot of
|
||||
storage and is mostly immutable.
|
||||
*/
|
||||
class Triangle {
|
||||
private:
|
||||
friend class CollisionDetection;
|
||||
friend class Ray;
|
||||
|
||||
Vector3 _vertex[3];
|
||||
|
||||
/** edgeDirection[i] is the normalized vector v[i+1] - v[i] */
|
||||
Vector3 edgeDirection[3];
|
||||
float edgeMagnitude[3];
|
||||
Plane _plane;
|
||||
Vector3::Axis _primaryAxis;
|
||||
|
||||
/** vertex[1] - vertex[0] */
|
||||
Vector3 _edge01;
|
||||
|
||||
/** vertex[2] - vertex[0] */
|
||||
Vector3 _edge02;
|
||||
|
||||
float _area;
|
||||
|
||||
void init(const Vector3& v0, const Vector3& v1, const Vector3& v2);
|
||||
|
||||
public:
|
||||
|
||||
Triangle(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b);
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
Triangle();
|
||||
|
||||
Triangle(const Vector3& v0, const Vector3& v1, const Vector3& v2);
|
||||
|
||||
~Triangle();
|
||||
|
||||
/** 0, 1, or 2 */
|
||||
inline const Vector3& vertex(int n) const {
|
||||
debugAssert((n >= 0) && (n < 3));
|
||||
return _vertex[n];
|
||||
}
|
||||
|
||||
/** vertex[1] - vertex[0] */
|
||||
inline const Vector3& edge01() const {
|
||||
return _edge01;
|
||||
}
|
||||
|
||||
/** vertex[2] - vertex[0] */
|
||||
inline const Vector3& edge02() const {
|
||||
return _edge02;
|
||||
}
|
||||
|
||||
float area() const;
|
||||
|
||||
Vector3::Axis primaryAxis() const {
|
||||
return _primaryAxis;
|
||||
}
|
||||
|
||||
const Vector3& normal() const;
|
||||
|
||||
/** Barycenter */
|
||||
Vector3 center() const;
|
||||
|
||||
const Plane& plane() const;
|
||||
|
||||
/** Returns a random point in the triangle. */
|
||||
Vector3 randomPoint() const;
|
||||
|
||||
inline void getRandomSurfacePoint(Vector3& P,
|
||||
Vector3& N = Vector3::dummy) const {
|
||||
P = randomPoint();
|
||||
N = normal();
|
||||
}
|
||||
/**
|
||||
For two triangles to be equal they must have
|
||||
the same vertices <I>in the same order</I>.
|
||||
That is, vertex[0] == vertex[0], etc.
|
||||
*/
|
||||
inline bool operator==(const Triangle& other) const {
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
if (_vertex[i] != other._vertex[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
inline size_t hashCode() const {
|
||||
return
|
||||
_vertex[0].hashCode() +
|
||||
(_vertex[1].hashCode() >> 2) +
|
||||
(_vertex[2].hashCode() >> 3);
|
||||
}
|
||||
|
||||
void getBounds(class AABox&) const;
|
||||
|
||||
};
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
template <> struct HashTrait<G3D::Triangle> {
|
||||
static size_t hashCode(const G3D::Triangle& key) { return key.hashCode(); }
|
||||
};
|
||||
|
||||
|
||||
template<> struct BoundsTrait<class G3D::Triangle> {
|
||||
static void getBounds(const G3D::Triangle& t, G3D::AABox& out) { t.getBounds(out); }
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
@file UprightFrame.h
|
||||
|
||||
@author Morgan McGuire, [email protected]
|
||||
*/
|
||||
|
||||
#ifndef G3D_UPRIGHTFRAME_H
|
||||
#define G3D_UPRIGHTFRAME_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Spline.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/CoordinateFrame.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Coordinate frame expressed in Euler angles.
|
||||
Unlike a G3D::Quat, UprightFrame always keeps the reference frame from rolling about its own z axis.
|
||||
Particularly useful for cameras.
|
||||
|
||||
@sa G3D::CoordinateFrame, G3D::Matrix4, G3D::PhysicsFrame, G3D::UprightSpline, G3D::UprightSplineManipulator
|
||||
*/
|
||||
class UprightFrame {
|
||||
public:
|
||||
|
||||
Vector3 translation;
|
||||
|
||||
/** -pi/2 < pitch < pi/2 in radians about the X-axis */
|
||||
float pitch;
|
||||
|
||||
/** In radians about the Y-axis */
|
||||
float yaw;
|
||||
|
||||
inline UprightFrame(const Vector3& t = Vector3::zero(), float p = 0, float y = 0)
|
||||
: translation(t), pitch(p), yaw(y) {}
|
||||
|
||||
UprightFrame(const CoordinateFrame& cframe);
|
||||
|
||||
CoordinateFrame toCoordinateFrame() const;
|
||||
|
||||
/** Supports implicit cast to CoordinateFrame */
|
||||
inline operator CoordinateFrame() const {
|
||||
return toCoordinateFrame();
|
||||
}
|
||||
|
||||
/** Required for use with spline */
|
||||
UprightFrame operator+(const UprightFrame& other) const;
|
||||
|
||||
/** Required for use with spline */
|
||||
UprightFrame operator*(const float k) const;
|
||||
|
||||
/**
|
||||
Unwraps the yaw values in the elements of the array such that
|
||||
they still represent the same angles but strictly increase/decrease
|
||||
without wrapping about zero. For use with Spline<UprightFrame>
|
||||
*/
|
||||
static void unwrapYaw(UprightFrame* a, int N);
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
};
|
||||
|
||||
/** Shortest-path linear velocity spline for camera positions. Always keeps the camera from rolling.
|
||||
@sa G3D::UprightSplineManipulator, G3D::UprightFrame
|
||||
*/
|
||||
class UprightSpline : public Spline<UprightFrame> {
|
||||
protected:
|
||||
|
||||
virtual void ensureShortestPath(UprightFrame* A, int N) const {
|
||||
UprightFrame::unwrapYaw(A, N);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+457
@@ -0,0 +1,457 @@
|
||||
/**
|
||||
@file Vector2.h
|
||||
|
||||
2D vector class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2008-11-30
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_VECTOR2_H
|
||||
#define G3D_VECTOR2_H
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Table.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
#include "G3D/Vector2int16.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class Vector2;
|
||||
class Vector3;
|
||||
class Vector4;
|
||||
|
||||
/**
|
||||
Do not subclass-- this implementation makes assumptions about the
|
||||
memory layout.
|
||||
*/
|
||||
class Vector2 {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Vector2&) const;
|
||||
bool operator>(const Vector2&) const;
|
||||
bool operator<=(const Vector2&) const;
|
||||
bool operator>=(const Vector2&) const;
|
||||
|
||||
public:
|
||||
float x;
|
||||
float y;
|
||||
|
||||
/** Creates the zero vector */
|
||||
Vector2();
|
||||
Vector2(class TextInput& t);
|
||||
Vector2(class BinaryInput& b);
|
||||
Vector2(float x, float y);
|
||||
Vector2(float coordinate[2]);
|
||||
Vector2(double coordinate[2]);
|
||||
Vector2(const Vector2& other);
|
||||
Vector2(const class Vector2int16& other);
|
||||
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
void serialize(class TextOutput& t) const;
|
||||
void deserialize(class TextInput& t);
|
||||
|
||||
float& operator[](int i);
|
||||
const float& operator[](int i) const;
|
||||
operator float*();
|
||||
operator const float*() const;
|
||||
|
||||
// assignment and comparison
|
||||
Vector2& operator=(const Vector2& other);
|
||||
bool operator==(const Vector2& other) const;
|
||||
bool operator!=(const Vector2& other) const;
|
||||
size_t hashCode() const;
|
||||
bool fuzzyEq(const Vector2& other) const;
|
||||
bool fuzzyNe(const Vector2& other) const;
|
||||
|
||||
/** Returns true if this vector has finite length */
|
||||
bool isFinite() const;
|
||||
|
||||
/** Returns true if this vector has length == 0 */
|
||||
bool isZero() const;
|
||||
|
||||
/** Returns true if this vector has length == 1 */
|
||||
bool isUnit() const;
|
||||
|
||||
// arithmetic operations
|
||||
Vector2 operator+(const Vector2& v) const;
|
||||
Vector2 operator-(const Vector2& v) const;
|
||||
Vector2 operator*(float s) const;
|
||||
|
||||
/** Array (pointwise) multiplication */
|
||||
Vector2 operator*(const Vector2& v) const;
|
||||
|
||||
/** Array division */
|
||||
Vector2 operator/(const Vector2& v) const;
|
||||
Vector2 operator/(float s) const;
|
||||
|
||||
/** Unary minus */
|
||||
Vector2 operator-() const;
|
||||
|
||||
/** x + y */
|
||||
inline float sum() const {
|
||||
return x + y;
|
||||
}
|
||||
|
||||
/**
|
||||
Linear interpolation
|
||||
*/
|
||||
inline Vector2 lerp(const Vector2& v, float alpha) const {
|
||||
return (*this) + (v - *this) * alpha;
|
||||
}
|
||||
|
||||
inline Vector2 clamp(const Vector2& low, const Vector2& high) const {
|
||||
return Vector2(
|
||||
G3D::clamp(x, low.x, high.x),
|
||||
G3D::clamp(y, low.y, high.y));
|
||||
}
|
||||
|
||||
inline Vector2 clamp(float low, float high) const {
|
||||
return Vector2(
|
||||
(float)G3D::clamp(x, low, high),
|
||||
(float)G3D::clamp(y, low, high));
|
||||
}
|
||||
|
||||
// arithmetic updates
|
||||
Vector2& operator+=(const Vector2&);
|
||||
Vector2& operator-=(const Vector2&);
|
||||
Vector2& operator*=(float);
|
||||
Vector2& operator/=(float);
|
||||
Vector2& operator*=(const Vector2&);
|
||||
Vector2& operator/=(const Vector2&);
|
||||
|
||||
// vector operations
|
||||
|
||||
/** */
|
||||
float length() const;
|
||||
|
||||
/** Returns a unit-length vector */
|
||||
Vector2 direction() const;
|
||||
|
||||
/**
|
||||
Potentially less accurate but faster than direction().
|
||||
Only works if System::hasSSE is true.
|
||||
*/
|
||||
Vector2 fastDirection() const {
|
||||
return direction();
|
||||
}
|
||||
|
||||
float squaredLength() const;
|
||||
float dot(const Vector2& s) const;
|
||||
|
||||
/**
|
||||
Make this vector have unit length and return the old length.
|
||||
If the vector length was less than tolerance, do not normalize.
|
||||
*/
|
||||
float unitize(float fTolerance = 1e-06);
|
||||
|
||||
Vector2 min(const Vector2& v) const;
|
||||
Vector2 max(const Vector2& v) const;
|
||||
|
||||
/** Uniformly distributed random vector on the unit sphere */
|
||||
static Vector2 random();
|
||||
|
||||
// Special values.
|
||||
// Intentionally not inlined: see Matrix3::identity() for details.
|
||||
static const Vector2& zero();
|
||||
inline static const Vector2& one() { static const Vector2 v(1, 1); return v; }
|
||||
static const Vector2& unitX();
|
||||
static const Vector2& unitY();
|
||||
static const Vector2& inf();
|
||||
static const Vector2& nan();
|
||||
/** smallest (most negative) representable vector */
|
||||
static const Vector2& minFinite();
|
||||
/** Largest representable vector */
|
||||
static const Vector2& maxFinite();
|
||||
|
||||
std::string toString() const;
|
||||
|
||||
// 2-char swizzles
|
||||
|
||||
Vector2 xx() const;
|
||||
Vector2 yx() const;
|
||||
Vector2 xy() const;
|
||||
Vector2 yy() const;
|
||||
|
||||
// 3-char swizzles
|
||||
|
||||
Vector3 xxx() const;
|
||||
Vector3 yxx() const;
|
||||
Vector3 xyx() const;
|
||||
Vector3 yyx() const;
|
||||
Vector3 xxy() const;
|
||||
Vector3 yxy() const;
|
||||
Vector3 xyy() const;
|
||||
Vector3 yyy() const;
|
||||
|
||||
// 4-char swizzles
|
||||
|
||||
Vector4 xxxx() const;
|
||||
Vector4 yxxx() const;
|
||||
Vector4 xyxx() const;
|
||||
Vector4 yyxx() const;
|
||||
Vector4 xxyx() const;
|
||||
Vector4 yxyx() const;
|
||||
Vector4 xyyx() const;
|
||||
Vector4 yyyx() const;
|
||||
Vector4 xxxy() const;
|
||||
Vector4 yxxy() const;
|
||||
Vector4 xyxy() const;
|
||||
Vector4 yyxy() const;
|
||||
Vector4 xxyy() const;
|
||||
Vector4 yxyy() const;
|
||||
Vector4 xyyy() const;
|
||||
Vector4 yyyy() const;
|
||||
|
||||
};
|
||||
|
||||
inline Vector2 operator*(double s, const Vector2& v) {
|
||||
return v * (float)s;
|
||||
}
|
||||
|
||||
inline Vector2 operator*(float s, const Vector2& v) {
|
||||
return v * s;
|
||||
}
|
||||
|
||||
inline Vector2 operator*(int s, const Vector2& v) {
|
||||
return v * (float)s;
|
||||
}
|
||||
|
||||
|
||||
inline Vector2::Vector2 () : x(0.0f), y(0.0f) {
|
||||
}
|
||||
|
||||
|
||||
inline Vector2::Vector2(float _x, float _y) : x(_x), y(_y) {
|
||||
}
|
||||
|
||||
|
||||
inline Vector2::Vector2 (float afCoordinate[2]) {
|
||||
x = afCoordinate[0];
|
||||
y = afCoordinate[1];
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2::Vector2 (double afCoordinate[2]) {
|
||||
x = (float)afCoordinate[0];
|
||||
y = (float)afCoordinate[1];
|
||||
}
|
||||
|
||||
|
||||
inline Vector2::Vector2 (const Vector2& rkVector) {
|
||||
x = rkVector.x;
|
||||
y = rkVector.y;
|
||||
}
|
||||
|
||||
|
||||
inline Vector2::Vector2 (const Vector2int16& v) : x(v.x), y(v.y) {
|
||||
}
|
||||
|
||||
|
||||
inline float& Vector2::operator[] (int i) {
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
|
||||
inline const float& Vector2::operator[] (int i) const {
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
|
||||
inline Vector2::operator float* () {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
inline Vector2::operator const float* () const {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
|
||||
inline Vector2& Vector2::operator= (const Vector2& rkVector) {
|
||||
x = rkVector.x;
|
||||
y = rkVector.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline bool Vector2::operator== (const Vector2& rkVector) const {
|
||||
return ( x == rkVector.x && y == rkVector.y);
|
||||
}
|
||||
|
||||
|
||||
inline bool Vector2::operator!= (const Vector2& rkVector) const {
|
||||
return ( x != rkVector.x || y != rkVector.y);
|
||||
}
|
||||
|
||||
|
||||
inline Vector2 Vector2::operator+ (const Vector2& rkVector) const {
|
||||
return Vector2(x + rkVector.x, y + rkVector.y);
|
||||
}
|
||||
|
||||
|
||||
inline Vector2 Vector2::operator- (const Vector2& rkVector) const {
|
||||
return Vector2(x - rkVector.x, y - rkVector.y);
|
||||
}
|
||||
|
||||
|
||||
inline Vector2 Vector2::operator* (float fScalar) const {
|
||||
return Vector2(fScalar*x, fScalar*y);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2 Vector2::operator- () const {
|
||||
return Vector2( -x, -y);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2& Vector2::operator+= (const Vector2& rkVector) {
|
||||
x += rkVector.x;
|
||||
y += rkVector.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2& Vector2::operator-= (const Vector2& rkVector) {
|
||||
x -= rkVector.x;
|
||||
y -= rkVector.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2& Vector2::operator*= (float fScalar) {
|
||||
x *= fScalar;
|
||||
y *= fScalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
inline Vector2& Vector2::operator*= (const Vector2& rkVector) {
|
||||
x *= rkVector.x;
|
||||
y *= rkVector.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2& Vector2::operator/= (const Vector2& rkVector) {
|
||||
x /= rkVector.x;
|
||||
y /= rkVector.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
inline Vector2 Vector2::operator* (const Vector2& rkVector) const {
|
||||
return Vector2(x * rkVector.x, y * rkVector.y);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2 Vector2::operator/ (const Vector2& rkVector) const {
|
||||
return Vector2(x / rkVector.x, y / rkVector.y);
|
||||
}
|
||||
|
||||
|
||||
inline float Vector2::squaredLength () const {
|
||||
return x*x + y*y;
|
||||
}
|
||||
|
||||
|
||||
inline float Vector2::length () const {
|
||||
return sqrtf(x*x + y*y);
|
||||
}
|
||||
|
||||
|
||||
inline Vector2 Vector2::direction () const {
|
||||
float lenSquared = x * x + y * y;
|
||||
|
||||
if (lenSquared != 1.0f) {
|
||||
return *this / sqrtf(lenSquared);
|
||||
} else {
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline float Vector2::dot (const Vector2& rkVector) const {
|
||||
return x*rkVector.x + y*rkVector.y;
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2 Vector2::min(const Vector2 &v) const {
|
||||
return Vector2(G3D::min(v.x, x), G3D::min(v.y, y));
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline Vector2 Vector2::max(const Vector2 &v) const {
|
||||
return Vector2(G3D::max(v.x, x), G3D::max(v.y, y));
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline bool Vector2::fuzzyEq(const Vector2& other) const {
|
||||
return G3D::fuzzyEq((*this - other).squaredLength(), 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline bool Vector2::fuzzyNe(const Vector2& other) const {
|
||||
return G3D::fuzzyNe((*this - other).squaredLength(), 0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline bool Vector2::isFinite() const {
|
||||
return G3D::isFinite(x) && G3D::isFinite(y);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline bool Vector2::isZero() const {
|
||||
return (x == 0.0f) && (y == 0.0f);
|
||||
}
|
||||
|
||||
|
||||
|
||||
inline bool Vector2::isUnit() const {
|
||||
return squaredLength() == 1.0f;
|
||||
}
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
template <>
|
||||
struct HashTrait<G3D::Vector2> {
|
||||
static size_t hashCode(const G3D::Vector2& key) {
|
||||
return key.hashCode();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// Intentionally outside namespace to avoid operator overloading confusion
|
||||
inline G3D::Vector2 operator*(double s, const G3D::Vector2& v) {
|
||||
return v * (float)s;
|
||||
}
|
||||
inline G3D::Vector2 operator*(int s, const G3D::Vector2& v) {
|
||||
return v * (float)s;
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,137 @@
|
||||
/**
|
||||
@file Vector2int16.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-08-09
|
||||
@edited 2004-01-03
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef VECTOR2INT16_H
|
||||
#define VECTOR2INT16_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A Vector2 that packs its fields into uint16s.
|
||||
*/
|
||||
#ifdef G3D_WIN32
|
||||
// Switch to tight alignment
|
||||
#pragma pack(push, 2)
|
||||
#endif
|
||||
|
||||
class Vector2int16 {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Vector2int16&) const;
|
||||
bool operator>(const Vector2int16&) const;
|
||||
bool operator<=(const Vector2int16&) const;
|
||||
bool operator>=(const Vector2int16&) const;
|
||||
|
||||
public:
|
||||
G3D::int16 x;
|
||||
G3D::int16 y;
|
||||
|
||||
Vector2int16() : x(0), y(0) {}
|
||||
Vector2int16(G3D::int16 _x, G3D::int16 _y) : x(_x), y(_y){}
|
||||
Vector2int16(const class Vector2& v);
|
||||
Vector2int16(class BinaryInput& bi);
|
||||
|
||||
inline G3D::int16& operator[] (int i) {
|
||||
debugAssert(((unsigned int)i) <= 1);
|
||||
return ((G3D::int16*)this)[i];
|
||||
}
|
||||
|
||||
inline const G3D::int16& operator[] (int i) const {
|
||||
debugAssert(((unsigned int)i) <= 1);
|
||||
return ((G3D::int16*)this)[i];
|
||||
}
|
||||
|
||||
inline Vector2int16 operator+(const Vector2int16& other) const {
|
||||
return Vector2int16(x + other.x, y + other.y);
|
||||
}
|
||||
|
||||
inline Vector2int16 operator-(const Vector2int16& other) const {
|
||||
return Vector2int16(x - other.x, y - other.y);
|
||||
}
|
||||
|
||||
inline Vector2int16 operator*(const Vector2int16& other) const {
|
||||
return Vector2int16(x * other.x, y * other.y);
|
||||
}
|
||||
|
||||
inline Vector2int16 operator*(const int s) const {
|
||||
return Vector2int16(x * s, y * s);
|
||||
}
|
||||
|
||||
inline Vector2int16& operator+=(const Vector2int16& other) {
|
||||
x += other.x;
|
||||
y += other.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/** Shifts both x and y */
|
||||
inline Vector2int16 operator>>(const int s) const {
|
||||
return Vector2int16(x >> s, y >> s);
|
||||
}
|
||||
|
||||
/** Shifts both x and y */
|
||||
inline Vector2int16 operator<<(const int s) const {
|
||||
return Vector2int16(x << s, y << s);
|
||||
}
|
||||
|
||||
inline Vector2int16& operator-=(const Vector2int16& other) {
|
||||
x -= other.x;
|
||||
y -= other.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Vector2int16& operator*=(const Vector2int16& other) {
|
||||
x *= other.x;
|
||||
y *= other.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Vector2int16 clamp(const Vector2int16& lo, const Vector2int16& hi);
|
||||
|
||||
inline bool operator== (const Vector2int16& rkVector) const {
|
||||
return ((int32*)this)[0] == ((int32*)&rkVector)[0];
|
||||
}
|
||||
|
||||
inline bool operator!= (const Vector2int16& rkVector) const {
|
||||
return ((int32*)this)[0] != ((int32*)&rkVector)[0];
|
||||
}
|
||||
|
||||
Vector2int16 max(const Vector2int16& v) const {
|
||||
return Vector2int16(iMax(x, v.x), iMax(y, v.y));
|
||||
}
|
||||
|
||||
Vector2int16 min(const Vector2int16& v) const {
|
||||
return Vector2int16(iMin(x, v.x), iMin(y, v.y));
|
||||
}
|
||||
|
||||
void serialize(class BinaryOutput& bo) const;
|
||||
void deserialize(class BinaryInput& bi);
|
||||
}
|
||||
#if defined(G3D_LINUX) || defined(G3D_OSX)
|
||||
__attribute((aligned(1)))
|
||||
#endif
|
||||
;
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
template<> struct HashTrait<G3D::Vector2int16> {
|
||||
static size_t hashCode(const G3D::Vector2int16& key) { return static_cast<size_t>(key.x + ((int)key.y << 16)); }
|
||||
};
|
||||
|
||||
#endif
|
||||
+761
@@ -0,0 +1,761 @@
|
||||
/**
|
||||
@file Vector3.h
|
||||
|
||||
3D vector class
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2008-11-01
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_VECTOR3_H
|
||||
#define G3D_VECTOR3_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Vector2.h"
|
||||
#include "G3D/Table.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
#include "G3D/PositionTrait.h"
|
||||
#include "G3D/Vector2.h"
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
#ifdef SSE
|
||||
// If you receive an error on this line, it is because you do not have the file
|
||||
// xmmintrin.h needed for MMX & SSE extensions. Download and install
|
||||
//
|
||||
// http://download.microsoft.com/download/vstudio60ent/SP5/Wideband-Full/WIN98Me/EN-US/vs6sp5.exe
|
||||
// and
|
||||
// http://download.microsoft.com/download/vb60ent/Update/6/W9X2KXP/EN-US/vcpp5.exe
|
||||
//
|
||||
// to get this file.
|
||||
# include <xmmintrin.h>
|
||||
#endif
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class Vector2;
|
||||
class Vector3;
|
||||
class Vector4;
|
||||
class Vector4int8;
|
||||
|
||||
/**
|
||||
<B>Swizzles</B>
|
||||
Vector classes have swizzle operators, e.g. <CODE>v.xy()</CODE>, that
|
||||
allow selection of arbitrary sub-fields. These cannot be used as write
|
||||
masks. Examples
|
||||
|
||||
<PRE>
|
||||
Vector3 v(1, 2, 3);
|
||||
Vector3 j;
|
||||
Vector2 b;
|
||||
|
||||
b = v.xz();
|
||||
j = b.xx();
|
||||
</PRE>
|
||||
|
||||
|
||||
<B>Warning</B>
|
||||
|
||||
Do not subclass-- this implementation makes assumptions about the
|
||||
memory layout.
|
||||
*/
|
||||
class Vector3 {
|
||||
private:
|
||||
/**
|
||||
Reflect this vector about the (not necessarily unit) normal.
|
||||
Note that if used for a collision or ray reflection you
|
||||
must negate the resulting vector to get a direction pointing
|
||||
<I>away</I> from the collision.
|
||||
|
||||
<PRE>
|
||||
V' N V
|
||||
|
||||
r ^ -,
|
||||
\ | /
|
||||
\|/
|
||||
</PRE>
|
||||
|
||||
See also Vector3::reflectionDirection
|
||||
*/
|
||||
Vector3 reflectAbout(const Vector3& normal) const;
|
||||
|
||||
// Hidden operators
|
||||
bool operator<(const Vector3&) const;
|
||||
bool operator>(const Vector3&) const;
|
||||
bool operator<=(const Vector3&) const;
|
||||
bool operator>=(const Vector3&) const;
|
||||
|
||||
public:
|
||||
// construction
|
||||
Vector3();
|
||||
|
||||
/** Divides by 127 */
|
||||
Vector3(const Vector4int8&);
|
||||
explicit Vector3(class BinaryInput& b);
|
||||
Vector3(float _x, float _y, float _z);
|
||||
explicit Vector3(const class Vector2& v, float _z);
|
||||
explicit Vector3(float coordinate[3]);
|
||||
explicit Vector3(double coordinate[3]);
|
||||
Vector3(const Vector3& rkVector);
|
||||
Vector3(const class Vector3int16& v);
|
||||
explicit Vector3(class TextInput& t);
|
||||
|
||||
/** Format is three float32's */
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
/** Format is "(%f, %f, %f)" */
|
||||
void serialize(class TextOutput& t) const;
|
||||
void deserialize(class TextInput& t);
|
||||
|
||||
// coordinates
|
||||
float x, y, z;
|
||||
|
||||
// access vector V as V[0] = V.x, V[1] = V.y, V[2] = V.z
|
||||
//
|
||||
// WARNING. These member functions rely on
|
||||
// (1) Vector3 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);
|
||||
|
||||
inline operator float* () {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
operator const float* () const {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
enum Axis {X_AXIS=0, Y_AXIS=1, Z_AXIS=2, DETECT_AXIS=-1};
|
||||
|
||||
/**
|
||||
Returns the largest dimension. Particularly convenient for determining
|
||||
which plane to project a triangle onto for point-in-polygon tests.
|
||||
*/
|
||||
Axis primaryAxis() const;
|
||||
|
||||
// assignment and comparison
|
||||
Vector3& operator= (const Vector3& rkVector);
|
||||
bool operator== (const Vector3& rkVector) const;
|
||||
bool operator!= (const Vector3& rkVector) const;
|
||||
size_t hashCode() const;
|
||||
bool fuzzyEq(const Vector3& other) const;
|
||||
bool fuzzyNe(const Vector3& other) const;
|
||||
|
||||
/** Returns true if this vector has finite length. */
|
||||
bool isFinite() const;
|
||||
|
||||
/** Returns true if this vector has length ~= 0 */
|
||||
bool isZero() const;
|
||||
|
||||
/** Returns true if this vector has length ~= 1 */
|
||||
bool isUnit() const;
|
||||
|
||||
// arithmetic operations
|
||||
Vector3 operator+ (const Vector3& v) const;
|
||||
Vector3 operator- (const Vector3& v) const;
|
||||
Vector3 operator* (float s) const;
|
||||
Vector3 operator/ (float s) const;
|
||||
Vector3 operator* (const Vector3& v) const;
|
||||
Vector3 operator/ (const Vector3& v) const;
|
||||
Vector3 operator- () const;
|
||||
|
||||
// arithmetic updates
|
||||
Vector3& operator+= (const Vector3& v);
|
||||
Vector3& operator-= (const Vector3& v);
|
||||
Vector3& operator*= (float s);
|
||||
Vector3& operator/= (float s);
|
||||
Vector3& operator*= (const Vector3& v);
|
||||
Vector3& operator/= (const Vector3& v);
|
||||
|
||||
/** Same as magnitude */
|
||||
float length() const;
|
||||
|
||||
float magnitude() const;
|
||||
|
||||
/**
|
||||
The result is a nan vector if the length is almost zero.
|
||||
*/
|
||||
Vector3 direction() const;
|
||||
|
||||
/**
|
||||
Potentially less accurate but faster than direction().
|
||||
Only works if System::hasSSE is true.
|
||||
*/
|
||||
Vector3 fastDirection() const;
|
||||
|
||||
|
||||
/**
|
||||
See also G3D::Ray::reflect.
|
||||
The length is 1.
|
||||
<PRE>
|
||||
V' N V
|
||||
|
||||
r ^ /
|
||||
\ | /
|
||||
\|'-
|
||||
</PRE>
|
||||
*/
|
||||
Vector3 reflectionDirection(const Vector3& normal) const;
|
||||
|
||||
|
||||
/**
|
||||
Returns Vector3::zero() if the length is nearly zero, otherwise
|
||||
returns a unit vector.
|
||||
*/
|
||||
inline Vector3 directionOrZero() const {
|
||||
float mag = magnitude();
|
||||
if (G3D::fuzzyEq(mag, 0.0f)) {
|
||||
return Vector3::zero();
|
||||
} else if (G3D::fuzzyEq(mag, 1.0f)) {
|
||||
return *this;
|
||||
} else {
|
||||
return *this * (1.0f / mag);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Returns the direction of a refracted ray,
|
||||
where iExit is the index of refraction for the
|
||||
previous material and iEnter is the index of refraction
|
||||
for the new material. Like Vector3::reflectionDirection,
|
||||
the result has length 1 and is
|
||||
pointed <I>away</I> from the intersection.
|
||||
|
||||
Returns Vector3::zero() in the case of total internal refraction.
|
||||
|
||||
@param iOutside The index of refraction (eta) outside
|
||||
(on the <I>positive</I> normal side) of the surface.
|
||||
|
||||
@param iInside The index of refraction (eta) inside
|
||||
(on the <I>negative</I> normal side) of the surface.
|
||||
|
||||
See also G3D::Ray::refract.
|
||||
<PRE>
|
||||
N V
|
||||
|
||||
^ /
|
||||
| /
|
||||
|'-
|
||||
__--
|
||||
V'<--
|
||||
</PRE>
|
||||
*/
|
||||
Vector3 refractionDirection(
|
||||
const Vector3& normal,
|
||||
float iInside,
|
||||
float iOutside) const;
|
||||
|
||||
/** Synonym for direction */
|
||||
inline Vector3 unit() const {
|
||||
return direction();
|
||||
}
|
||||
|
||||
/** Returns a normalized vector. May be computed with lower
|
||||
precision than unit */
|
||||
inline Vector3 fastUnit() const {
|
||||
return fastDirection();
|
||||
}
|
||||
|
||||
/** Same as squaredMagnitude */
|
||||
float squaredLength() const;
|
||||
|
||||
float squaredMagnitude () const;
|
||||
|
||||
float dot(const Vector3& rkVector) const;
|
||||
|
||||
float unitize(float tolerance = 1e-06);
|
||||
|
||||
/** Cross product. Note that two cross products in a row
|
||||
can be computed more cheaply: v1 x (v2 x v3) = (v1 dot v3) v2 - (v1 dot v2) v3.
|
||||
*/
|
||||
Vector3 cross(const Vector3& rkVector) const;
|
||||
Vector3 unitCross (const Vector3& rkVector) const;
|
||||
|
||||
/**
|
||||
Returns a matrix such that v.cross() * w = v.cross(w).
|
||||
<PRE>
|
||||
[ 0 -v.z v.y ]
|
||||
[ v.z 0 -v.x ]
|
||||
[ -v.y v.x 0 ]
|
||||
</PRE>
|
||||
*/
|
||||
class Matrix3 cross() const;
|
||||
|
||||
Vector3 min(const Vector3 &v) const;
|
||||
Vector3 max(const Vector3 &v) const;
|
||||
|
||||
/** Smallest element */
|
||||
inline float min() const {
|
||||
return G3D::min(G3D::min(x, y), z);
|
||||
}
|
||||
|
||||
/** Largest element */
|
||||
inline float max() const {
|
||||
return G3D::max(G3D::max(x, y), z);
|
||||
}
|
||||
|
||||
std::string toString() const;
|
||||
|
||||
inline Vector3 clamp(const Vector3& low, const Vector3& high) const {
|
||||
return Vector3(
|
||||
G3D::clamp(x, low.x, high.x),
|
||||
G3D::clamp(y, low.y, high.y),
|
||||
G3D::clamp(z, low.z, high.z));
|
||||
}
|
||||
|
||||
inline Vector3 clamp(float low, float high) const {
|
||||
return Vector3(
|
||||
G3D::clamp(x, low, high),
|
||||
G3D::clamp(y, low, high),
|
||||
G3D::clamp(z, low, high));
|
||||
}
|
||||
|
||||
/**
|
||||
Linear interpolation
|
||||
*/
|
||||
inline Vector3 lerp(const Vector3& v, float alpha) const {
|
||||
return (*this) + (v - *this) * alpha;
|
||||
}
|
||||
|
||||
/** Gram-Schmidt orthonormalization. */
|
||||
static void orthonormalize (Vector3 akVector[3]);
|
||||
|
||||
/** Random unit vector, uniformly distributed */
|
||||
static Vector3 random();
|
||||
|
||||
/** Random unit vector, distributed
|
||||
so that the probability of V is proportional
|
||||
to max(V dot Normal, 0).
|
||||
|
||||
@cite Henrik Wann Jensen, Realistic Image Synthesis using Photon Mapping eqn 2.24
|
||||
*/
|
||||
static Vector3 cosRandom(const Vector3& normal);
|
||||
|
||||
|
||||
/**
|
||||
Random vector distributed over the hemisphere about normal.
|
||||
*/
|
||||
static Vector3 hemiRandom(const Vector3& normal);
|
||||
|
||||
// Input W must be initialize to a nonzero vector, output is {U,V,W}
|
||||
// an orthonormal basis. A hint is provided about whether or not W
|
||||
// is already unit length.
|
||||
static void generateOrthonormalBasis (Vector3& rkU, Vector3& rkV,
|
||||
Vector3& rkW, bool bUnitLengthW = true);
|
||||
|
||||
inline float sum() const {
|
||||
return x + y + z;
|
||||
}
|
||||
|
||||
inline float average() const {
|
||||
return sum() / 3.0f;
|
||||
}
|
||||
|
||||
// Special values.
|
||||
inline static const Vector3& zero() { static Vector3 v(0, 0, 0); return v; }
|
||||
inline static const Vector3& one() { static Vector3 v(1, 1, 1); return v; }
|
||||
inline static const Vector3& unitX() { static Vector3 v(1, 0, 0); return v; }
|
||||
inline static const Vector3& unitY() { static Vector3 v(0, 1, 0); return v; }
|
||||
inline static const Vector3& unitZ() { static Vector3 v(0, 0, 1); return v; }
|
||||
inline static const Vector3& inf() { static Vector3 v((float)G3D::inf(), (float)G3D::inf(), (float)G3D::inf()); return v; }
|
||||
inline static const Vector3& nan() { static Vector3 v((float)G3D::nan(), (float)G3D::nan(), (float)G3D::nan()); return v; }
|
||||
/** Smallest (most negative) representable vector */
|
||||
inline static const Vector3& minFinite(){ static Vector3 v(-FLT_MAX, -FLT_MAX, -FLT_MAX); return v; }
|
||||
/** Largest representable vector */
|
||||
inline static const Vector3& maxFinite(){ static Vector3 v(FLT_MAX, FLT_MAX, FLT_MAX); return v; }
|
||||
|
||||
// 2-char swizzles
|
||||
|
||||
Vector2 xx() const;
|
||||
Vector2 yx() const;
|
||||
Vector2 zx() const;
|
||||
Vector2 xy() const;
|
||||
Vector2 yy() const;
|
||||
Vector2 zy() const;
|
||||
Vector2 xz() const;
|
||||
Vector2 yz() const;
|
||||
Vector2 zz() const;
|
||||
|
||||
// 3-char swizzles
|
||||
|
||||
Vector3 xxx() const;
|
||||
Vector3 yxx() const;
|
||||
Vector3 zxx() const;
|
||||
Vector3 xyx() const;
|
||||
Vector3 yyx() const;
|
||||
Vector3 zyx() const;
|
||||
Vector3 xzx() const;
|
||||
Vector3 yzx() const;
|
||||
Vector3 zzx() const;
|
||||
Vector3 xxy() const;
|
||||
Vector3 yxy() const;
|
||||
Vector3 zxy() const;
|
||||
Vector3 xyy() const;
|
||||
Vector3 yyy() const;
|
||||
Vector3 zyy() const;
|
||||
Vector3 xzy() const;
|
||||
Vector3 yzy() const;
|
||||
Vector3 zzy() const;
|
||||
Vector3 xxz() const;
|
||||
Vector3 yxz() const;
|
||||
Vector3 zxz() const;
|
||||
Vector3 xyz() const;
|
||||
Vector3 yyz() const;
|
||||
Vector3 zyz() const;
|
||||
Vector3 xzz() const;
|
||||
Vector3 yzz() const;
|
||||
Vector3 zzz() const;
|
||||
|
||||
// 4-char swizzles
|
||||
|
||||
Vector4 xxxx() const;
|
||||
Vector4 yxxx() const;
|
||||
Vector4 zxxx() const;
|
||||
Vector4 xyxx() const;
|
||||
Vector4 yyxx() const;
|
||||
Vector4 zyxx() const;
|
||||
Vector4 xzxx() const;
|
||||
Vector4 yzxx() const;
|
||||
Vector4 zzxx() const;
|
||||
Vector4 xxyx() const;
|
||||
Vector4 yxyx() const;
|
||||
Vector4 zxyx() const;
|
||||
Vector4 xyyx() const;
|
||||
Vector4 yyyx() const;
|
||||
Vector4 zyyx() const;
|
||||
Vector4 xzyx() const;
|
||||
Vector4 yzyx() const;
|
||||
Vector4 zzyx() const;
|
||||
Vector4 xxzx() const;
|
||||
Vector4 yxzx() const;
|
||||
Vector4 zxzx() const;
|
||||
Vector4 xyzx() const;
|
||||
Vector4 yyzx() const;
|
||||
Vector4 zyzx() const;
|
||||
Vector4 xzzx() const;
|
||||
Vector4 yzzx() const;
|
||||
Vector4 zzzx() const;
|
||||
Vector4 xxxy() const;
|
||||
Vector4 yxxy() const;
|
||||
Vector4 zxxy() const;
|
||||
Vector4 xyxy() const;
|
||||
Vector4 yyxy() const;
|
||||
Vector4 zyxy() const;
|
||||
Vector4 xzxy() const;
|
||||
Vector4 yzxy() const;
|
||||
Vector4 zzxy() const;
|
||||
Vector4 xxyy() const;
|
||||
Vector4 yxyy() const;
|
||||
Vector4 zxyy() const;
|
||||
Vector4 xyyy() const;
|
||||
Vector4 yyyy() const;
|
||||
Vector4 zyyy() const;
|
||||
Vector4 xzyy() const;
|
||||
Vector4 yzyy() const;
|
||||
Vector4 zzyy() const;
|
||||
Vector4 xxzy() const;
|
||||
Vector4 yxzy() const;
|
||||
Vector4 zxzy() const;
|
||||
Vector4 xyzy() const;
|
||||
Vector4 yyzy() const;
|
||||
Vector4 zyzy() const;
|
||||
Vector4 xzzy() const;
|
||||
Vector4 yzzy() const;
|
||||
Vector4 zzzy() const;
|
||||
Vector4 xxxz() const;
|
||||
Vector4 yxxz() const;
|
||||
Vector4 zxxz() const;
|
||||
Vector4 xyxz() const;
|
||||
Vector4 yyxz() const;
|
||||
Vector4 zyxz() const;
|
||||
Vector4 xzxz() const;
|
||||
Vector4 yzxz() const;
|
||||
Vector4 zzxz() const;
|
||||
Vector4 xxyz() const;
|
||||
Vector4 yxyz() const;
|
||||
Vector4 zxyz() const;
|
||||
Vector4 xyyz() const;
|
||||
Vector4 yyyz() const;
|
||||
Vector4 zyyz() const;
|
||||
Vector4 xzyz() const;
|
||||
Vector4 yzyz() const;
|
||||
Vector4 zzyz() const;
|
||||
Vector4 xxzz() const;
|
||||
Vector4 yxzz() const;
|
||||
Vector4 zxzz() const;
|
||||
Vector4 xyzz() const;
|
||||
Vector4 yyzz() const;
|
||||
Vector4 zyzz() const;
|
||||
Vector4 xzzz() const;
|
||||
Vector4 yzzz() const;
|
||||
Vector4 zzzz() const;
|
||||
|
||||
/** A value that can be passed to ignore a parameter. Never look at the result of dummy. */
|
||||
static Vector3 dummy;
|
||||
};
|
||||
|
||||
inline G3D::Vector3 operator*(float s, const G3D::Vector3& v) {
|
||||
return v * s;
|
||||
}
|
||||
|
||||
inline G3D::Vector3 operator*(double s, const G3D::Vector3& v) {
|
||||
return v * (float)s;
|
||||
}
|
||||
|
||||
inline G3D::Vector3 operator*(int s, const G3D::Vector3& v) {
|
||||
return v * (float)s;
|
||||
}
|
||||
|
||||
std::ostream& operator<<(std::ostream& os, const Vector3&);
|
||||
|
||||
|
||||
void serialize(const Vector3::Axis& a, class BinaryOutput& bo);
|
||||
void deserialize(Vector3::Axis& a, class BinaryInput& bo);
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3::Vector3() : x(0.0f), y(0.0f), z(0.0f) {
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline Vector3::Vector3 (float fX, float fY, float fZ) : x(fX), y(fY), z(fZ) {
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3::Vector3 (float V[3]) : x(V[0]), y(V[1]), z(V[2]){
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3::Vector3 (double V[3]) : x((float)V[0]), y((float)V[1]), z((float)V[2]){
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3::Vector3 (const Vector3& V) : x(V.x), y(V.y), z(V.z) {
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
//inline Vector3::Vector3 (const __m128& m) {
|
||||
// Cast from SSE packed floats
|
||||
// *this = *(Vector3*)&m;
|
||||
//}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline const float& Vector3::operator[] (int i) const {
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
inline float& Vector3::operator[] (int i) {
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3& Vector3::operator= (const Vector3& rkVector) {
|
||||
x = rkVector.x;
|
||||
y = rkVector.y;
|
||||
z = rkVector.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline bool Vector3::fuzzyEq(const Vector3& other) const {
|
||||
return G3D::fuzzyEq((*this - other).squaredMagnitude(), 0);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline bool Vector3::fuzzyNe(const Vector3& other) const {
|
||||
return G3D::fuzzyNe((*this - other).squaredMagnitude(), 0);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline bool Vector3::isFinite() const {
|
||||
return G3D::isFinite(x) && G3D::isFinite(y) && G3D::isFinite(z);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool Vector3::operator== (const Vector3& rkVector) const {
|
||||
return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool Vector3::operator!= (const Vector3& rkVector) const {
|
||||
return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::operator+ (const Vector3& rkVector) const {
|
||||
return Vector3(x + rkVector.x, y + rkVector.y, z + rkVector.z);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::operator- (const Vector3& rkVector) const {
|
||||
return Vector3(x - rkVector.x, y - rkVector.y, z - rkVector.z);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::operator* (const Vector3& rkVector) const {
|
||||
return Vector3(x * rkVector.x, y * rkVector.y, z * rkVector.z);
|
||||
}
|
||||
|
||||
inline Vector3 Vector3::operator*(float f) const {
|
||||
return Vector3(x * f, y * f, z * f);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::operator/ (const Vector3& rkVector) const {
|
||||
return Vector3(x / rkVector.x, y / rkVector.y, z / rkVector.z);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::operator- () const {
|
||||
return Vector3(-x, -y, -z);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3& Vector3::operator+= (const Vector3& rkVector) {
|
||||
x += rkVector.x;
|
||||
y += rkVector.y;
|
||||
z += rkVector.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3& Vector3::operator-= (const Vector3& rkVector) {
|
||||
x -= rkVector.x;
|
||||
y -= rkVector.y;
|
||||
z -= rkVector.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3& Vector3::operator*= (float fScalar) {
|
||||
x *= fScalar;
|
||||
y *= fScalar;
|
||||
z *= fScalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3& Vector3::operator*= (const Vector3& rkVector) {
|
||||
x *= rkVector.x;
|
||||
y *= rkVector.y;
|
||||
z *= rkVector.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3& Vector3::operator/= (const Vector3& rkVector) {
|
||||
x /= rkVector.x;
|
||||
y /= rkVector.y;
|
||||
z /= rkVector.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float Vector3::squaredMagnitude () const {
|
||||
return x*x + y*y + z*z;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float Vector3::squaredLength () const {
|
||||
return squaredMagnitude();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float Vector3::magnitude() const {
|
||||
return sqrtf(x*x + y*y + z*z);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float Vector3::length() const {
|
||||
return magnitude();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::direction () const {
|
||||
float lenSquared = squaredMagnitude();
|
||||
float invSqrt = 1.0f / sqrtf(lenSquared);
|
||||
return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline Vector3 Vector3::fastDirection () const {
|
||||
float lenSquared = x * x + y * y + z * z;
|
||||
float invSqrt = rsq(lenSquared);
|
||||
return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float Vector3::dot (const Vector3& rkVector) const {
|
||||
return x*rkVector.x + y*rkVector.y + z*rkVector.z;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::cross (const Vector3& rkVector) const {
|
||||
return Vector3(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
|
||||
x*rkVector.y - y*rkVector.x);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::unitCross (const Vector3& rkVector) const {
|
||||
Vector3 kCross(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
|
||||
x*rkVector.y - y*rkVector.x);
|
||||
kCross.unitize();
|
||||
return kCross;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::min(const Vector3 &v) const {
|
||||
return Vector3(G3D::min(v.x, x), G3D::min(v.y, y), G3D::min(v.z, z));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector3 Vector3::max(const Vector3 &v) const {
|
||||
return Vector3(G3D::max(v.x, x), G3D::max(v.y, y), G3D::max(v.z, z));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool Vector3::isZero() const {
|
||||
return G3D::fuzzyEq(squaredMagnitude(), 0.0f);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline bool Vector3::isUnit() const {
|
||||
return G3D::fuzzyEq(squaredMagnitude(), 1.0f);
|
||||
}
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
|
||||
template <>
|
||||
struct HashTrait<G3D::Vector3> {
|
||||
static size_t hashCode(const G3D::Vector3& key) {
|
||||
return key.hashCode();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<> struct PositionTrait<class G3D::Vector2> {
|
||||
static void getPosition(const G3D::Vector2& v, G3D::Vector3& p) { p = G3D::Vector3(v, 0); }
|
||||
};
|
||||
|
||||
template<> struct PositionTrait<class G3D::Vector3> {
|
||||
static void getPosition(const G3D::Vector3& v, G3D::Vector3& p) { p = v; }
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,130 @@
|
||||
/**
|
||||
@file Vector3int16.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2003-04-07
|
||||
@edited 2003-06-24
|
||||
Copyright 2000-2004, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef VECTOR3INT16_H
|
||||
#define VECTOR3INT16_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A Vector3 that packs its fields into uint16s.
|
||||
*/
|
||||
#ifdef G3D_WIN32
|
||||
// Switch to tight alignment
|
||||
#pragma pack(push, 2)
|
||||
#endif
|
||||
|
||||
class Vector3int16 {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Vector3int16&) const;
|
||||
bool operator>(const Vector3int16&) const;
|
||||
bool operator<=(const Vector3int16&) const;
|
||||
bool operator>=(const Vector3int16&) const;
|
||||
|
||||
public:
|
||||
G3D::int16 x;
|
||||
G3D::int16 y;
|
||||
G3D::int16 z;
|
||||
|
||||
Vector3int16() : x(0), y(0), z(0) {}
|
||||
Vector3int16(G3D::int16 _x, G3D::int16 _y, G3D::int16 _z) : x(_x), y(_y), z(_z) {}
|
||||
Vector3int16(const class Vector3& v);
|
||||
Vector3int16(class BinaryInput& bi);
|
||||
|
||||
void serialize(class BinaryOutput& bo) const;
|
||||
void deserialize(class BinaryInput& bi);
|
||||
|
||||
inline G3D::int16& operator[] (int i) {
|
||||
debugAssert(i <= 2);
|
||||
return ((G3D::int16*)this)[i];
|
||||
}
|
||||
|
||||
inline const G3D::int16& operator[] (int i) const {
|
||||
debugAssert(i <= 2);
|
||||
return ((G3D::int16*)this)[i];
|
||||
}
|
||||
|
||||
inline Vector3int16 operator+(const Vector3int16& other) const {
|
||||
return Vector3int16(x + other.x, y + other.y, z + other.z);
|
||||
}
|
||||
|
||||
inline Vector3int16 operator-(const Vector3int16& other) const {
|
||||
return Vector3int16(x - other.x, y - other.y, z - other.z);
|
||||
}
|
||||
|
||||
inline Vector3int16 operator*(const Vector3int16& other) const {
|
||||
return Vector3int16(x * other.x, y * other.y, z * other.z);
|
||||
}
|
||||
|
||||
inline Vector3int16 operator*(const int s) const {
|
||||
return Vector3int16(x * s, y * s, z * s);
|
||||
}
|
||||
|
||||
inline Vector3int16& operator+=(const Vector3int16& other) {
|
||||
x += other.x;
|
||||
y += other.y;
|
||||
z += other.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Vector3int16& operator-=(const Vector3int16& other) {
|
||||
x -= other.x;
|
||||
y -= other.y;
|
||||
z -= other.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Vector3int16& operator*=(const Vector3int16& other) {
|
||||
x *= other.x;
|
||||
y *= other.y;
|
||||
z *= other.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline bool operator== (const Vector3int16& rkVector) const {
|
||||
return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
|
||||
}
|
||||
|
||||
inline bool operator!= (const Vector3int16& rkVector) const {
|
||||
return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
|
||||
}
|
||||
|
||||
Vector3int16 max(const Vector3int16& v) const {
|
||||
return Vector3int16(iMax(x, v.x), iMax(y, v.y), iMax(z, v.z));
|
||||
}
|
||||
|
||||
Vector3int16 min(const Vector3int16& v) const {
|
||||
return Vector3int16(iMin(x, v.x), iMin(y, v.y), iMin(z, v.z));
|
||||
}
|
||||
|
||||
std::string toString() const;
|
||||
}
|
||||
#if defined(G3D_LINUX) || defined(G3D_OSX)
|
||||
__attribute((aligned(1)))
|
||||
#endif
|
||||
;
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
template <> struct HashTrait<G3D::Vector3int16> {
|
||||
static size_t hashCode(const G3D::Vector3int16& key) { return static_cast<size_t>(key.x + ((int)key.y << 5) + ((int)key.z << 10)); }
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
@file Vector3int32.h
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2008-07-01
|
||||
@edited 2008-07-01
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef VECTOR3INT32_H
|
||||
#define VECTOR3INT32_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A Vector3 that packs its fields into uint32s.
|
||||
*/
|
||||
#ifdef G3D_WIN32
|
||||
// Switch to tight alignment
|
||||
#pragma pack(push, 4)
|
||||
#endif
|
||||
|
||||
class Vector3int32 {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Vector3int32&) const;
|
||||
bool operator>(const Vector3int32&) const;
|
||||
bool operator<=(const Vector3int32&) const;
|
||||
bool operator>=(const Vector3int32&) const;
|
||||
|
||||
public:
|
||||
G3D::int32 x;
|
||||
G3D::int32 y;
|
||||
G3D::int32 z;
|
||||
|
||||
Vector3int32() : x(0), y(0), z(0) {}
|
||||
Vector3int32(int _x, int _y, int _z) : x(_x), y(_y), z(_z) {}
|
||||
Vector3int32(const class Vector3int16& v);
|
||||
Vector3int32(const class Vector3& v);
|
||||
Vector3int32(class BinaryInput& bi);
|
||||
|
||||
void serialize(class BinaryOutput& bo) const;
|
||||
void deserialize(class BinaryInput& bi);
|
||||
|
||||
inline G3D::int32& operator[] (int i) {
|
||||
debugAssert(i <= 2);
|
||||
return ((G3D::int32*)this)[i];
|
||||
}
|
||||
|
||||
inline const G3D::int32& operator[] (int i) const {
|
||||
debugAssert(i <= 2);
|
||||
return ((G3D::int32*)this)[i];
|
||||
}
|
||||
|
||||
inline Vector3int32 operator+(const Vector3int32& other) const {
|
||||
return Vector3int32(x + other.x, y + other.y, z + other.z);
|
||||
}
|
||||
|
||||
inline Vector3int32 operator-(const Vector3int32& other) const {
|
||||
return Vector3int32(x - other.x, y - other.y, z - other.z);
|
||||
}
|
||||
|
||||
inline Vector3int32 operator*(const Vector3int32& other) const {
|
||||
return Vector3int32(x * other.x, y * other.y, z * other.z);
|
||||
}
|
||||
|
||||
inline Vector3int32 operator*(const int s) const {
|
||||
return Vector3int32(x * s, y * s, z * s);
|
||||
}
|
||||
|
||||
inline Vector3int32& operator+=(const Vector3int32& other) {
|
||||
x += other.x;
|
||||
y += other.y;
|
||||
z += other.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Vector3int32& operator-=(const Vector3int32& other) {
|
||||
x -= other.x;
|
||||
y -= other.y;
|
||||
z -= other.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline Vector3int32& operator*=(const Vector3int32& other) {
|
||||
x *= other.x;
|
||||
y *= other.y;
|
||||
z *= other.z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline bool operator== (const Vector3int32& rkVector) const {
|
||||
return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
|
||||
}
|
||||
|
||||
inline bool operator!= (const Vector3int32& rkVector) const {
|
||||
return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
|
||||
}
|
||||
|
||||
Vector3int32 max(const Vector3int32& v) const {
|
||||
return Vector3int32(iMax(x, v.x), iMax(y, v.y), iMax(z, v.z));
|
||||
}
|
||||
|
||||
Vector3int32 min(const Vector3int32& v) const {
|
||||
return Vector3int32(iMin(x, v.x), iMin(y, v.y), iMin(z, v.z));
|
||||
}
|
||||
|
||||
std::string toString() const;
|
||||
}
|
||||
#if defined(G3D_LINUX) || defined(G3D_OSX)
|
||||
__attribute((aligned(1)))
|
||||
#endif
|
||||
;
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
#pragma pack(pop)
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
template <> struct HashTrait<G3D::Vector3int32> {
|
||||
static size_t hashCode(const G3D::Vector3int32& key) {
|
||||
// Mask for the top bit of a uint32
|
||||
const G3D::uint32 top = (1 << 31);
|
||||
// Mask for the bottom 10 bits of a uint32
|
||||
const G3D::uint32 bot = 0x000003FF;
|
||||
return static_cast<size_t>(((key.x & top) | ((key.y & top) >> 1) | ((key.z & top) >> 2)) |
|
||||
(((key.x & bot) << 19) ^ ((key.y & bot) << 10) ^ (key.z & bot)));
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
+717
@@ -0,0 +1,717 @@
|
||||
/**
|
||||
@file Vector4.h
|
||||
|
||||
Homogeneous vector class.
|
||||
|
||||
@maintainer Morgan McGuire, [email protected]
|
||||
|
||||
@created 2002-07-09
|
||||
@edited 2008-11-01
|
||||
|
||||
Copyright 2000-2008, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_VECTOR4_H
|
||||
#define G3D_VECTOR4_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector2.h"
|
||||
#include "G3D/Table.h"
|
||||
#include "G3D/HashTrait.h"
|
||||
#include "G3D/PositionTrait.h"
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class Vector2;
|
||||
class Vector3;
|
||||
class Vector4;
|
||||
class Vector4int8;
|
||||
|
||||
/**
|
||||
Do not subclass-- this implementation makes assumptions about the
|
||||
memory layout.
|
||||
*/
|
||||
class Vector4 {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Vector4&) const;
|
||||
bool operator>(const Vector4&) const;
|
||||
bool operator<=(const Vector4&) const;
|
||||
bool operator>=(const Vector4&) const;
|
||||
|
||||
public:
|
||||
// construction
|
||||
Vector4();
|
||||
Vector4(float fX, float fY, float fZ, float fW);
|
||||
Vector4(float afCoordinate[4]);
|
||||
Vector4(const Vector4& rkVector);
|
||||
Vector4(const class Color4& c);
|
||||
Vector4(const Vector3& rkVector, float fW);
|
||||
Vector4(const Vector2& v1, const Vector2& v2);
|
||||
Vector4(const Vector2& v1, float fz, float fw);
|
||||
|
||||
/** Divides by 127 when converting */
|
||||
Vector4(const Vector4int8&);
|
||||
|
||||
Vector4(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
// coordinates
|
||||
float x, y, z, w;
|
||||
|
||||
// access vector V as V[0] = V.x, V[1] = V.y, V[2] = V.z, etc.
|
||||
//
|
||||
// WARNING. These member functions rely on
|
||||
// (1) Vector4 not having virtual functions
|
||||
// (2) the data packed in a 4*sizeof(float) memory block
|
||||
float& operator[] (int i);
|
||||
const float& operator[] (int i) const;
|
||||
operator float* ();
|
||||
operator const float* () const;
|
||||
|
||||
// assignment and comparison
|
||||
Vector4& operator= (const Vector4& rkVector);
|
||||
bool operator== (const Vector4& rkVector) const;
|
||||
bool operator!= (const Vector4& rkVector) const;
|
||||
|
||||
inline void set(float _x, float _y, float _z, float _w) {
|
||||
x = _x;
|
||||
y = _y;
|
||||
z = _z;
|
||||
w = _w;
|
||||
}
|
||||
|
||||
inline void set(const Vector3& v, float _w) {
|
||||
x = v.x;
|
||||
y = v.y;
|
||||
z = v.z;
|
||||
w = _w;
|
||||
}
|
||||
|
||||
inline void set(const Vector2& v, float _z, float _w) {
|
||||
x = v.x;
|
||||
y = v.y;
|
||||
z = _z;
|
||||
w = _w;
|
||||
}
|
||||
|
||||
size_t hashCode() const;
|
||||
bool fuzzyEq(const Vector4& other) const;
|
||||
bool fuzzyNe(const Vector4& other) const;
|
||||
|
||||
inline static const Vector4& inf() { static Vector4 v((float)G3D::inf(), (float)G3D::inf(), (float)G3D::inf(), (float)G3D::inf()); return v; }
|
||||
inline static const Vector4& nan() { static Vector4 v((float)G3D::nan(), (float)G3D::nan(), (float)G3D::nan(), (float)G3D::nan()); return v; }
|
||||
|
||||
/** sqrt(this->dot(*this)) */
|
||||
float length() const;
|
||||
float squaredLength() const;
|
||||
|
||||
inline float sum() const {
|
||||
return x + y + z + w;
|
||||
}
|
||||
|
||||
/** Returns true if this vector has finite length */
|
||||
bool isFinite() const;
|
||||
|
||||
/** Returns true if this vector has length == 0 */
|
||||
bool isZero() const;
|
||||
|
||||
/** Returns true if this vector has length == 1 */
|
||||
bool isUnit() const;
|
||||
|
||||
// arithmetic operations
|
||||
Vector4 operator+ (const Vector4& rkVector) const;
|
||||
Vector4 operator- (const Vector4& rkVector) const;
|
||||
|
||||
inline Vector4 operator*(const Vector4& rkVector) const {
|
||||
return Vector4(x * rkVector.x, y * rkVector.y, z * rkVector.z, w * rkVector.w);
|
||||
}
|
||||
|
||||
inline Vector4 operator/(const Vector4& rkVector) const {
|
||||
return Vector4(x / rkVector.x, y / rkVector.y, z / rkVector.z, w / rkVector.w);
|
||||
}
|
||||
|
||||
Vector4 operator*(const class Matrix4& M) const;
|
||||
|
||||
Vector4 operator* (float fScalar) const;
|
||||
Vector4 operator/ (float fScalar) const;
|
||||
Vector4 operator- () const;
|
||||
friend Vector4 operator* (float, const Vector4& rkVector);
|
||||
|
||||
// arithmetic updates
|
||||
Vector4& operator+= (const Vector4& rkVector);
|
||||
Vector4& operator-= (const Vector4& rkVector);
|
||||
Vector4& operator*= (float fScalar);
|
||||
Vector4& operator/= (float fScalar);
|
||||
|
||||
inline Vector4 clamp(const Vector4& low, const Vector4& high) const {
|
||||
return Vector4(
|
||||
G3D::clamp(x, low.x, high.x),
|
||||
G3D::clamp(y, low.y, high.y),
|
||||
G3D::clamp(z, low.z, high.z),
|
||||
G3D::clamp(w, low.w, high.w));
|
||||
}
|
||||
|
||||
inline Vector4 clamp(float low, float high) const {
|
||||
return Vector4(
|
||||
G3D::clamp(x, low, high),
|
||||
G3D::clamp(y, low, high),
|
||||
G3D::clamp(z, low, high),
|
||||
G3D::clamp(w, low, high));
|
||||
}
|
||||
|
||||
float dot (const Vector4& rkVector) const;
|
||||
|
||||
Vector4 min(const Vector4& v) const;
|
||||
Vector4 max(const Vector4& v) const;
|
||||
|
||||
std::string toString() const;
|
||||
|
||||
/**
|
||||
Linear interpolation
|
||||
*/
|
||||
Vector4 lerp(const Vector4& v, float alpha) const;
|
||||
|
||||
// 2-char swizzles
|
||||
|
||||
Vector2 xx() const;
|
||||
Vector2 yx() const;
|
||||
Vector2 zx() const;
|
||||
Vector2 wx() const;
|
||||
Vector2 xy() const;
|
||||
Vector2 yy() const;
|
||||
Vector2 zy() const;
|
||||
Vector2 wy() const;
|
||||
Vector2 xz() const;
|
||||
Vector2 yz() const;
|
||||
Vector2 zz() const;
|
||||
Vector2 wz() const;
|
||||
Vector2 xw() const;
|
||||
Vector2 yw() const;
|
||||
Vector2 zw() const;
|
||||
Vector2 ww() const;
|
||||
|
||||
// 3-char swizzles
|
||||
|
||||
Vector3 xxx() const;
|
||||
Vector3 yxx() const;
|
||||
Vector3 zxx() const;
|
||||
Vector3 wxx() const;
|
||||
Vector3 xyx() const;
|
||||
Vector3 yyx() const;
|
||||
Vector3 zyx() const;
|
||||
Vector3 wyx() const;
|
||||
Vector3 xzx() const;
|
||||
Vector3 yzx() const;
|
||||
Vector3 zzx() const;
|
||||
Vector3 wzx() const;
|
||||
Vector3 xwx() const;
|
||||
Vector3 ywx() const;
|
||||
Vector3 zwx() const;
|
||||
Vector3 wwx() const;
|
||||
Vector3 xxy() const;
|
||||
Vector3 yxy() const;
|
||||
Vector3 zxy() const;
|
||||
Vector3 wxy() const;
|
||||
Vector3 xyy() const;
|
||||
Vector3 yyy() const;
|
||||
Vector3 zyy() const;
|
||||
Vector3 wyy() const;
|
||||
Vector3 xzy() const;
|
||||
Vector3 yzy() const;
|
||||
Vector3 zzy() const;
|
||||
Vector3 wzy() const;
|
||||
Vector3 xwy() const;
|
||||
Vector3 ywy() const;
|
||||
Vector3 zwy() const;
|
||||
Vector3 wwy() const;
|
||||
Vector3 xxz() const;
|
||||
Vector3 yxz() const;
|
||||
Vector3 zxz() const;
|
||||
Vector3 wxz() const;
|
||||
Vector3 xyz() const;
|
||||
Vector3 yyz() const;
|
||||
Vector3 zyz() const;
|
||||
Vector3 wyz() const;
|
||||
Vector3 xzz() const;
|
||||
Vector3 yzz() const;
|
||||
Vector3 zzz() const;
|
||||
Vector3 wzz() const;
|
||||
Vector3 xwz() const;
|
||||
Vector3 ywz() const;
|
||||
Vector3 zwz() const;
|
||||
Vector3 wwz() const;
|
||||
Vector3 xxw() const;
|
||||
Vector3 yxw() const;
|
||||
Vector3 zxw() const;
|
||||
Vector3 wxw() const;
|
||||
Vector3 xyw() const;
|
||||
Vector3 yyw() const;
|
||||
Vector3 zyw() const;
|
||||
Vector3 wyw() const;
|
||||
Vector3 xzw() const;
|
||||
Vector3 yzw() const;
|
||||
Vector3 zzw() const;
|
||||
Vector3 wzw() const;
|
||||
Vector3 xww() const;
|
||||
Vector3 yww() const;
|
||||
Vector3 zww() const;
|
||||
Vector3 www() const;
|
||||
|
||||
// 4-char swizzles
|
||||
|
||||
Vector4 xxxx() const;
|
||||
Vector4 yxxx() const;
|
||||
Vector4 zxxx() const;
|
||||
Vector4 wxxx() const;
|
||||
Vector4 xyxx() const;
|
||||
Vector4 yyxx() const;
|
||||
Vector4 zyxx() const;
|
||||
Vector4 wyxx() const;
|
||||
Vector4 xzxx() const;
|
||||
Vector4 yzxx() const;
|
||||
Vector4 zzxx() const;
|
||||
Vector4 wzxx() const;
|
||||
Vector4 xwxx() const;
|
||||
Vector4 ywxx() const;
|
||||
Vector4 zwxx() const;
|
||||
Vector4 wwxx() const;
|
||||
Vector4 xxyx() const;
|
||||
Vector4 yxyx() const;
|
||||
Vector4 zxyx() const;
|
||||
Vector4 wxyx() const;
|
||||
Vector4 xyyx() const;
|
||||
Vector4 yyyx() const;
|
||||
Vector4 zyyx() const;
|
||||
Vector4 wyyx() const;
|
||||
Vector4 xzyx() const;
|
||||
Vector4 yzyx() const;
|
||||
Vector4 zzyx() const;
|
||||
Vector4 wzyx() const;
|
||||
Vector4 xwyx() const;
|
||||
Vector4 ywyx() const;
|
||||
Vector4 zwyx() const;
|
||||
Vector4 wwyx() const;
|
||||
Vector4 xxzx() const;
|
||||
Vector4 yxzx() const;
|
||||
Vector4 zxzx() const;
|
||||
Vector4 wxzx() const;
|
||||
Vector4 xyzx() const;
|
||||
Vector4 yyzx() const;
|
||||
Vector4 zyzx() const;
|
||||
Vector4 wyzx() const;
|
||||
Vector4 xzzx() const;
|
||||
Vector4 yzzx() const;
|
||||
Vector4 zzzx() const;
|
||||
Vector4 wzzx() const;
|
||||
Vector4 xwzx() const;
|
||||
Vector4 ywzx() const;
|
||||
Vector4 zwzx() const;
|
||||
Vector4 wwzx() const;
|
||||
Vector4 xxwx() const;
|
||||
Vector4 yxwx() const;
|
||||
Vector4 zxwx() const;
|
||||
Vector4 wxwx() const;
|
||||
Vector4 xywx() const;
|
||||
Vector4 yywx() const;
|
||||
Vector4 zywx() const;
|
||||
Vector4 wywx() const;
|
||||
Vector4 xzwx() const;
|
||||
Vector4 yzwx() const;
|
||||
Vector4 zzwx() const;
|
||||
Vector4 wzwx() const;
|
||||
Vector4 xwwx() const;
|
||||
Vector4 ywwx() const;
|
||||
Vector4 zwwx() const;
|
||||
Vector4 wwwx() const;
|
||||
Vector4 xxxy() const;
|
||||
Vector4 yxxy() const;
|
||||
Vector4 zxxy() const;
|
||||
Vector4 wxxy() const;
|
||||
Vector4 xyxy() const;
|
||||
Vector4 yyxy() const;
|
||||
Vector4 zyxy() const;
|
||||
Vector4 wyxy() const;
|
||||
Vector4 xzxy() const;
|
||||
Vector4 yzxy() const;
|
||||
Vector4 zzxy() const;
|
||||
Vector4 wzxy() const;
|
||||
Vector4 xwxy() const;
|
||||
Vector4 ywxy() const;
|
||||
Vector4 zwxy() const;
|
||||
Vector4 wwxy() const;
|
||||
Vector4 xxyy() const;
|
||||
Vector4 yxyy() const;
|
||||
Vector4 zxyy() const;
|
||||
Vector4 wxyy() const;
|
||||
Vector4 xyyy() const;
|
||||
Vector4 yyyy() const;
|
||||
Vector4 zyyy() const;
|
||||
Vector4 wyyy() const;
|
||||
Vector4 xzyy() const;
|
||||
Vector4 yzyy() const;
|
||||
Vector4 zzyy() const;
|
||||
Vector4 wzyy() const;
|
||||
Vector4 xwyy() const;
|
||||
Vector4 ywyy() const;
|
||||
Vector4 zwyy() const;
|
||||
Vector4 wwyy() const;
|
||||
Vector4 xxzy() const;
|
||||
Vector4 yxzy() const;
|
||||
Vector4 zxzy() const;
|
||||
Vector4 wxzy() const;
|
||||
Vector4 xyzy() const;
|
||||
Vector4 yyzy() const;
|
||||
Vector4 zyzy() const;
|
||||
Vector4 wyzy() const;
|
||||
Vector4 xzzy() const;
|
||||
Vector4 yzzy() const;
|
||||
Vector4 zzzy() const;
|
||||
Vector4 wzzy() const;
|
||||
Vector4 xwzy() const;
|
||||
Vector4 ywzy() const;
|
||||
Vector4 zwzy() const;
|
||||
Vector4 wwzy() const;
|
||||
Vector4 xxwy() const;
|
||||
Vector4 yxwy() const;
|
||||
Vector4 zxwy() const;
|
||||
Vector4 wxwy() const;
|
||||
Vector4 xywy() const;
|
||||
Vector4 yywy() const;
|
||||
Vector4 zywy() const;
|
||||
Vector4 wywy() const;
|
||||
Vector4 xzwy() const;
|
||||
Vector4 yzwy() const;
|
||||
Vector4 zzwy() const;
|
||||
Vector4 wzwy() const;
|
||||
Vector4 xwwy() const;
|
||||
Vector4 ywwy() const;
|
||||
Vector4 zwwy() const;
|
||||
Vector4 wwwy() const;
|
||||
Vector4 xxxz() const;
|
||||
Vector4 yxxz() const;
|
||||
Vector4 zxxz() const;
|
||||
Vector4 wxxz() const;
|
||||
Vector4 xyxz() const;
|
||||
Vector4 yyxz() const;
|
||||
Vector4 zyxz() const;
|
||||
Vector4 wyxz() const;
|
||||
Vector4 xzxz() const;
|
||||
Vector4 yzxz() const;
|
||||
Vector4 zzxz() const;
|
||||
Vector4 wzxz() const;
|
||||
Vector4 xwxz() const;
|
||||
Vector4 ywxz() const;
|
||||
Vector4 zwxz() const;
|
||||
Vector4 wwxz() const;
|
||||
Vector4 xxyz() const;
|
||||
Vector4 yxyz() const;
|
||||
Vector4 zxyz() const;
|
||||
Vector4 wxyz() const;
|
||||
Vector4 xyyz() const;
|
||||
Vector4 yyyz() const;
|
||||
Vector4 zyyz() const;
|
||||
Vector4 wyyz() const;
|
||||
Vector4 xzyz() const;
|
||||
Vector4 yzyz() const;
|
||||
Vector4 zzyz() const;
|
||||
Vector4 wzyz() const;
|
||||
Vector4 xwyz() const;
|
||||
Vector4 ywyz() const;
|
||||
Vector4 zwyz() const;
|
||||
Vector4 wwyz() const;
|
||||
Vector4 xxzz() const;
|
||||
Vector4 yxzz() const;
|
||||
Vector4 zxzz() const;
|
||||
Vector4 wxzz() const;
|
||||
Vector4 xyzz() const;
|
||||
Vector4 yyzz() const;
|
||||
Vector4 zyzz() const;
|
||||
Vector4 wyzz() const;
|
||||
Vector4 xzzz() const;
|
||||
Vector4 yzzz() const;
|
||||
Vector4 zzzz() const;
|
||||
Vector4 wzzz() const;
|
||||
Vector4 xwzz() const;
|
||||
Vector4 ywzz() const;
|
||||
Vector4 zwzz() const;
|
||||
Vector4 wwzz() const;
|
||||
Vector4 xxwz() const;
|
||||
Vector4 yxwz() const;
|
||||
Vector4 zxwz() const;
|
||||
Vector4 wxwz() const;
|
||||
Vector4 xywz() const;
|
||||
Vector4 yywz() const;
|
||||
Vector4 zywz() const;
|
||||
Vector4 wywz() const;
|
||||
Vector4 xzwz() const;
|
||||
Vector4 yzwz() const;
|
||||
Vector4 zzwz() const;
|
||||
Vector4 wzwz() const;
|
||||
Vector4 xwwz() const;
|
||||
Vector4 ywwz() const;
|
||||
Vector4 zwwz() const;
|
||||
Vector4 wwwz() const;
|
||||
Vector4 xxxw() const;
|
||||
Vector4 yxxw() const;
|
||||
Vector4 zxxw() const;
|
||||
Vector4 wxxw() const;
|
||||
Vector4 xyxw() const;
|
||||
Vector4 yyxw() const;
|
||||
Vector4 zyxw() const;
|
||||
Vector4 wyxw() const;
|
||||
Vector4 xzxw() const;
|
||||
Vector4 yzxw() const;
|
||||
Vector4 zzxw() const;
|
||||
Vector4 wzxw() const;
|
||||
Vector4 xwxw() const;
|
||||
Vector4 ywxw() const;
|
||||
Vector4 zwxw() const;
|
||||
Vector4 wwxw() const;
|
||||
Vector4 xxyw() const;
|
||||
Vector4 yxyw() const;
|
||||
Vector4 zxyw() const;
|
||||
Vector4 wxyw() const;
|
||||
Vector4 xyyw() const;
|
||||
Vector4 yyyw() const;
|
||||
Vector4 zyyw() const;
|
||||
Vector4 wyyw() const;
|
||||
Vector4 xzyw() const;
|
||||
Vector4 yzyw() const;
|
||||
Vector4 zzyw() const;
|
||||
Vector4 wzyw() const;
|
||||
Vector4 xwyw() const;
|
||||
Vector4 ywyw() const;
|
||||
Vector4 zwyw() const;
|
||||
Vector4 wwyw() const;
|
||||
Vector4 xxzw() const;
|
||||
Vector4 yxzw() const;
|
||||
Vector4 zxzw() const;
|
||||
Vector4 wxzw() const;
|
||||
Vector4 xyzw() const;
|
||||
Vector4 yyzw() const;
|
||||
Vector4 zyzw() const;
|
||||
Vector4 wyzw() const;
|
||||
Vector4 xzzw() const;
|
||||
Vector4 yzzw() const;
|
||||
Vector4 zzzw() const;
|
||||
Vector4 wzzw() const;
|
||||
Vector4 xwzw() const;
|
||||
Vector4 ywzw() const;
|
||||
Vector4 zwzw() const;
|
||||
Vector4 wwzw() const;
|
||||
Vector4 xxww() const;
|
||||
Vector4 yxww() const;
|
||||
Vector4 zxww() const;
|
||||
Vector4 wxww() const;
|
||||
Vector4 xyww() const;
|
||||
Vector4 yyww() const;
|
||||
Vector4 zyww() const;
|
||||
Vector4 wyww() const;
|
||||
Vector4 xzww() const;
|
||||
Vector4 yzww() const;
|
||||
Vector4 zzww() const;
|
||||
Vector4 wzww() const;
|
||||
Vector4 xwww() const;
|
||||
Vector4 ywww() const;
|
||||
Vector4 zwww() const;
|
||||
Vector4 wwww() const;
|
||||
|
||||
};
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4::Vector4() {
|
||||
x = y = z = w = 0;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline Vector4::Vector4 (float fX, float fY, float fZ, float fW) {
|
||||
x = fX;
|
||||
y = fY;
|
||||
z = fZ;
|
||||
w = fW;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4::Vector4 (float afCoordinate[4]) {
|
||||
x = afCoordinate[0];
|
||||
y = afCoordinate[1];
|
||||
z = afCoordinate[2];
|
||||
w = afCoordinate[3];
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4::Vector4(const Vector4& rkVector) {
|
||||
x = rkVector.x;
|
||||
y = rkVector.y;
|
||||
z = rkVector.z;
|
||||
w = rkVector.w;
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4::Vector4(const Vector3& rkVector, float fW) {
|
||||
x = rkVector.x;
|
||||
y = rkVector.y;
|
||||
z = rkVector.z;
|
||||
w = fW;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float& Vector4::operator[] (int i) {
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline const float& Vector4::operator[] (int i) const {
|
||||
return ((float*)this)[i];
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4::operator float* () {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
inline Vector4::operator const float* () const {
|
||||
return (float*)this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4& Vector4::operator= (const Vector4& rkVector) {
|
||||
x = rkVector.x;
|
||||
y = rkVector.y;
|
||||
z = rkVector.z;
|
||||
w = rkVector.w;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool Vector4::operator== (const Vector4& rkVector) const {
|
||||
return ( (x == rkVector.x) && (y == rkVector.y) && (z == rkVector.z) && (w == rkVector.w));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool Vector4::operator!= (const Vector4& rkVector) const {
|
||||
return ( x != rkVector.x || y != rkVector.y || z != rkVector.z || w != rkVector.w);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4 Vector4::operator+ (const Vector4& rkVector) const {
|
||||
return Vector4(x + rkVector.x, y + rkVector.y, z + rkVector.z, w + rkVector.w);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4 Vector4::operator- (const Vector4& rkVector) const {
|
||||
return Vector4(x - rkVector.x, y - rkVector.y, z - rkVector.z, w - rkVector.w);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4 Vector4::operator* (float fScalar) const {
|
||||
return Vector4(fScalar*x, fScalar*y, fScalar*z, fScalar*w);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4 Vector4::operator- () const {
|
||||
return Vector4( -x, -y, -z, -w);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4& Vector4::operator+= (const Vector4& rkVector) {
|
||||
x += rkVector.x;
|
||||
y += rkVector.y;
|
||||
z += rkVector.z;
|
||||
w += rkVector.w;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4& Vector4::operator-= (const Vector4& rkVector) {
|
||||
x -= rkVector.x;
|
||||
y -= rkVector.y;
|
||||
z -= rkVector.z;
|
||||
w -= rkVector.w;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline Vector4 Vector4::lerp(const Vector4& v, float alpha) const {
|
||||
return (*this) + (v - *this) * alpha;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4& Vector4::operator*= (float fScalar) {
|
||||
x *= fScalar;
|
||||
y *= fScalar;
|
||||
z *= fScalar;
|
||||
w *= fScalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline float Vector4::dot(const Vector4& rkVector) const {
|
||||
return x*rkVector.x + y*rkVector.y + z*rkVector.z + w*rkVector.w;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4 Vector4::min(const Vector4 &v) const {
|
||||
return Vector4(G3D::min(v.x, x), G3D::min(v.y, y), G3D::min(v.z, z), G3D::min(v.w, w));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline Vector4 Vector4::max(const Vector4 &v) const {
|
||||
return Vector4(G3D::max(v.x, x), G3D::max(v.y, y), G3D::max(v.z, z), G3D::max(v.w, w));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline bool Vector4::isZero() const {
|
||||
return (x == 0.0f) && (y == 0.0f) && (z == 0.0f) && (w == 0.0f);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline bool Vector4::isFinite() const {
|
||||
return G3D::isFinite(x) && G3D::isFinite(y) && G3D::isFinite(z) && G3D::isFinite(w);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline bool Vector4::isUnit() const {
|
||||
return squaredLength() == 1.0;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline float Vector4::length() const {
|
||||
return sqrtf(squaredLength());
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline float Vector4::squaredLength() const {
|
||||
return x * x + y * y + z * z + w * w;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
template <> struct HashTrait<G3D::Vector4> {
|
||||
static size_t hashCode(const G3D::Vector4& key) { return key.hashCode(); }
|
||||
};
|
||||
|
||||
|
||||
template<> struct PositionTrait<class G3D::Vector4> {
|
||||
static void getPosition(const G3D::Vector4& v, G3D::Vector3& p) { p = v.xyz(); }
|
||||
};
|
||||
|
||||
inline G3D::Vector4 operator* (float s, const G3D::Vector4& v) {
|
||||
return v * s;
|
||||
}
|
||||
|
||||
#endif
|
||||
+113
@@ -0,0 +1,113 @@
|
||||
/**
|
||||
@file Vector4int8.h
|
||||
|
||||
Homogeneous vector class.
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created 2007-02-09
|
||||
@edited 2007-02-09
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_VECTOR4INT8_H
|
||||
#define G3D_VECTOR4INT8_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
class Vector3;
|
||||
class Vector4;
|
||||
|
||||
/**
|
||||
Homogeneous vector stored efficiently in four signed int8s.
|
||||
|
||||
*/
|
||||
class Vector4int8 {
|
||||
private:
|
||||
// Hidden operators
|
||||
bool operator<(const Vector4int8&) const;
|
||||
bool operator>(const Vector4int8&) const;
|
||||
bool operator<=(const Vector4int8&) const;
|
||||
bool operator>=(const Vector4int8&) const;
|
||||
|
||||
|
||||
/** For fast operations, treat this packed data structure as
|
||||
an int32 */
|
||||
inline uint32& asInt32() {
|
||||
return *reinterpret_cast<uint32*>(this);
|
||||
}
|
||||
|
||||
inline const uint32& asInt32() const {
|
||||
return *reinterpret_cast<const uint32*>(this);
|
||||
}
|
||||
|
||||
public:
|
||||
// construction
|
||||
inline Vector4int8() : x(0), y(0), z(0), w(0) {}
|
||||
|
||||
/** Multiplies the source by 127 and clamps to (-128, 127) when converting */
|
||||
Vector4int8(const Vector4& source);
|
||||
|
||||
/** Multiplies the source by 127 and clamps to (-128, 127) when converting */
|
||||
Vector4int8(const Vector3& source, int8 w);
|
||||
|
||||
inline Vector4int8(int8 x, int8 y, int8 z, int8 w) : x(x), y(y), z(z), w(w) {}
|
||||
|
||||
Vector4int8(class BinaryInput& b);
|
||||
void serialize(class BinaryOutput& b) const;
|
||||
void deserialize(class BinaryInput& b);
|
||||
|
||||
// coordinates
|
||||
int8 x, y, z, w;
|
||||
|
||||
inline operator int8* () {
|
||||
return reinterpret_cast<int8*>(this);
|
||||
}
|
||||
|
||||
inline operator const int8* () const {
|
||||
return reinterpret_cast<const int8*>(this);
|
||||
}
|
||||
|
||||
// access vector V as V[0] = V.x, V[1] = V.y, V[2] = V.z, etc.
|
||||
//
|
||||
// WARNING. These member functions rely on
|
||||
// (1) Vector4int8 not having virtual functions
|
||||
// (2) the data packed in a 4*sizeof(int8) memory block
|
||||
inline int8& operator[] (int i) {
|
||||
debugAssert(i >= 0 && i <= 4);
|
||||
return ((int8*)this)[i];
|
||||
}
|
||||
|
||||
const int8& operator[] (int i) const {
|
||||
debugAssert(i >= 0 && i <= 4);
|
||||
return ((const int8*)this)[i];
|
||||
}
|
||||
|
||||
// assignment and comparison
|
||||
Vector4int8& operator= (const Vector4int8& other) {
|
||||
asInt32() = other.asInt32();
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline bool operator== (const Vector4int8& other) const {
|
||||
return asInt32() == other.asInt32();
|
||||
}
|
||||
|
||||
inline bool operator!= (const Vector4int8& other) const {
|
||||
return ! (*this == other);
|
||||
}
|
||||
|
||||
inline unsigned int hashCode() const {
|
||||
return asInt32();
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
@file WeakCache.h
|
||||
|
||||
@maintainer Morgan McGuire, graphics3d.com
|
||||
|
||||
@created 2007-05-16
|
||||
@edited 2007-05-16
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
#ifndef G3D_WEAKCACHE_H
|
||||
#define G3D_WEAKCACHE_H
|
||||
|
||||
#include "G3D/ReferenceCount.h"
|
||||
#include "G3D/Table.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
A cache that does not prevent its members from being garbage collected.
|
||||
Useful to avoid loading or computing an expression twice. Useful
|
||||
for memoization and dynamic programming.
|
||||
|
||||
Maintains a table of weak pointers. Weak pointers do not prevent
|
||||
an object from being garbage collected. If the object is garbage
|
||||
collected, the cache removes its reference.
|
||||
|
||||
There are no "contains" or "iterate" methods because elements can be
|
||||
flushed from the cache at any time if they are garbage collected.
|
||||
|
||||
Example:
|
||||
<pre>
|
||||
WeakCache<std::string, TextureRef> textureCache;
|
||||
|
||||
TextureRef loadTexture(std::string s) {
|
||||
TextureRef t = textureCache[s];
|
||||
|
||||
if (t.isNull()) {
|
||||
t = Texture::fromFile(s);
|
||||
textureCache.set(s, t);
|
||||
}
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
</pre>
|
||||
*/
|
||||
template<class Key, class ValueRef>
|
||||
class WeakCache {
|
||||
typedef WeakReferenceCountedPointer<typename ValueRef::element_type> ValueWeakRef;
|
||||
|
||||
private:
|
||||
|
||||
Table<Key, ValueWeakRef> table;
|
||||
|
||||
public:
|
||||
/**
|
||||
Returns NULL if the object is not in the cache
|
||||
*/
|
||||
ValueRef operator[](const Key& k) {
|
||||
if (table.containsKey(k)) {
|
||||
ValueWeakRef w = table[k];
|
||||
ValueRef s = w.createStrongPtr();
|
||||
if (s.isNull()) {
|
||||
// This object has been collected; clean out its key
|
||||
table.remove(k);
|
||||
}
|
||||
return s;
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void set(const Key& k, ValueRef v) {
|
||||
table.set(k, v);
|
||||
}
|
||||
|
||||
/** Removes k from the cache or does nothing if it is not currently in the cache.*/
|
||||
void remove(const Key& k) {
|
||||
if (table.containsKey(k)) {
|
||||
table.remove(k);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
/**
|
||||
@file WrapMode.h
|
||||
|
||||
@maintainer Morgan McGuire, graphics3d.com
|
||||
|
||||
@created 2007-04-17
|
||||
@edited 2007-04-17
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_WRAPMODE_H
|
||||
#define G3D_WRAPMODE_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/enumclass.h"
|
||||
|
||||
#ifdef IGNORE
|
||||
# undef IGNORE
|
||||
#endif
|
||||
#ifdef ZERO
|
||||
# undef ZERO
|
||||
#endif
|
||||
#ifdef ERROR
|
||||
# undef ERROR
|
||||
#endif
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Describes the behavior of G3D::Texture, G3D::Map2D, G3D::Image3, etc. when accessing an out-of-bounds
|
||||
pixel. Not all classes support all modes.
|
||||
|
||||
Refer to these as scoped enums, e.g., <code>WrapMode m = WrapMode::CLAMP;</code>.
|
||||
|
||||
WrapMode::IGNORE silently discards attempts to write to out
|
||||
of bounds locations and returns an undefined value for reading
|
||||
from out of bounds locations.
|
||||
|
||||
WrapMode::ERROR generates an error when the
|
||||
pixel indices are out of bounds
|
||||
|
||||
WrapMode::CLAMP makes out of bounds pixels equal to the last in-range pixel along that dimension.
|
||||
|
||||
WrapMode::TILE computes out of bounds pixels modulo the dimension
|
||||
|
||||
WrapMode::ZERO treats out of bounds values as the zero value, which varies in definition
|
||||
according to the class used. For example, with a G3D::Texture, ZERO = Color4(0,0,0,0).
|
||||
|
||||
Uses the "Intelligent Enum" design pattern
|
||||
http://www.codeguru.com/cpp/cpp/cpp_mfc/article.php/c4001/
|
||||
*/
|
||||
class WrapMode {
|
||||
public:
|
||||
/** Don't use this enum; use WrapMode instances instead. */
|
||||
enum Value {
|
||||
CLAMP,
|
||||
TILE,
|
||||
ZERO,
|
||||
IGNORE,
|
||||
ERROR
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
Value value;
|
||||
|
||||
public:
|
||||
|
||||
G3D_DECLARE_ENUM_CLASS_METHODS(WrapMode);
|
||||
|
||||
};
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
G3D_DECLARE_ENUM_CLASS_HASHCODE(G3D::WrapMode);
|
||||
|
||||
#endif
|
||||
+66
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
@file debug.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created 2001-08-26
|
||||
@edited 2006-02-16
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_DEBUG_H
|
||||
#define G3D_DEBUG_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#ifdef _MSC_VER
|
||||
#include <crtdbg.h>
|
||||
#endif
|
||||
|
||||
#include "G3D/debugPrintf.h"
|
||||
#include "G3D/debugAssert.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// Turn off 64-bit warnings
|
||||
# pragma warning(push)
|
||||
# pragma warning( disable : 4312)
|
||||
# pragma warning( disable : 4267)
|
||||
# pragma warning( disable : 4311)
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
Useful for debugging purposes.
|
||||
*/
|
||||
inline bool isValidHeapPointer(const void* x) {
|
||||
#ifdef _MSC_VER
|
||||
return
|
||||
(x != (void*)0xcccccccc) && (x != (void*)0xdeadbeef) && (x != (void*)0xfeeefeee);
|
||||
#else
|
||||
return x != NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if the pointer is likely to be
|
||||
a valid pointer (instead of an arbitrary number).
|
||||
Useful for debugging purposes.
|
||||
*/
|
||||
inline bool isValidPointer(const void* x) {
|
||||
#ifdef _MSC_VER
|
||||
return x != ((void*)0xcccccccc) && (x != (void*)0xdeadbeef) && (x != (void*)0xfeeefeee);
|
||||
#else
|
||||
return x != NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+236
@@ -0,0 +1,236 @@
|
||||
/**
|
||||
@file debugAssert.h
|
||||
|
||||
debugAssert(expression);
|
||||
debugAssertM(expression, message);
|
||||
|
||||
@cite
|
||||
John Robbins, Microsoft Systems Journal Bugslayer Column, Feb 1999.
|
||||
<A HREF="http://msdn.microsoft.com/library/periodic/period99/feb99_BUGSLAYE_BUGSLAYE.htm">
|
||||
http://msdn.microsoft.com/library/periodic/period99/feb99_BUGSLAYE_BUGSLAYE.htm</A>
|
||||
|
||||
@cite
|
||||
Douglas Cox, An assert() Replacement, Code of The Day, flipcode, Sept 19, 2000
|
||||
<A HREF="http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-AssertReplace&forum=cotd&id=-1">
|
||||
http://www.flipcode.com/cgi-bin/msg.cgi?showThread=COTD-AssertReplace&forum=cotd&id=-1</A>
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created 2001-08-26
|
||||
@edited 2006-01-12
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_DEBUGASSERT_H
|
||||
#define G3D_DEBUGASSERT_H
|
||||
|
||||
#include <string>
|
||||
#include "G3D/platform.h"
|
||||
|
||||
#include <cstdlib>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// conditional expression is constant
|
||||
# pragma warning (disable : 4127)
|
||||
#endif
|
||||
|
||||
#ifdef G3D_LINUX
|
||||
// Needed so we can define a global display
|
||||
// pointer for debugAssert.
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/Xutil.h>
|
||||
#include <X11/Xatom.h>
|
||||
#endif
|
||||
|
||||
#ifdef G3D_OSX
|
||||
// Need this for DebugStr()
|
||||
#import <CoreServices/CoreServices.h>
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
@def debugBreak()
|
||||
|
||||
Break at the current location (i.e. don't push a procedure stack frame
|
||||
before breaking).
|
||||
*/
|
||||
|
||||
/**
|
||||
@def debugAssert(exp)
|
||||
Breaks if the expression is false. If G3D_DEBUG_NOGUI is defined, prompts at
|
||||
the console, otherwise pops up a dialog. The user may then break (debug),
|
||||
ignore, ignore always, or halt the program.
|
||||
|
||||
The assertion is also posted to the clipboard under Win32.
|
||||
*/
|
||||
|
||||
/**
|
||||
@def debugAssertM(exp, msg)
|
||||
Breaks if the expression is false and displays a message. If G3D_DEBUG_NOGUI
|
||||
is defined, prompts at the console, otherwise pops up a dialog. The user may
|
||||
then break (debug), ignore, ignore always, or halt the program.
|
||||
|
||||
The assertion is also posted to the clipboard under Win32.
|
||||
*/
|
||||
|
||||
namespace G3D {
|
||||
typedef bool (*AssertionHook)(
|
||||
const char* _expression,
|
||||
const std::string& message,
|
||||
const char* filename,
|
||||
int lineNumber,
|
||||
bool& ignoreAlways,
|
||||
bool useGuiPrompt);
|
||||
|
||||
/**
|
||||
Allows customization of the global function invoked when a debugAssert fails.
|
||||
The initial value is G3D::_internal::_handleDebugAssert_. G3D will invoke
|
||||
rawBreak if the hook returns true. If NULL, assertions are not handled.
|
||||
*/
|
||||
void setAssertionHook(AssertionHook hook);
|
||||
|
||||
AssertionHook assertionHook();
|
||||
|
||||
/**
|
||||
Called by alwaysAssertM in case of failure in release mode. If returns
|
||||
true then the program exits with -1 (you can replace this with your own
|
||||
version that throws an exception or has other failure modes).
|
||||
*/
|
||||
void setFailureHook(AssertionHook hook);
|
||||
AssertionHook failureHook();
|
||||
|
||||
namespace _internal {
|
||||
extern AssertionHook _debugHook;
|
||||
extern AssertionHook _failureHook;
|
||||
} // internal
|
||||
} // G3D
|
||||
|
||||
/**
|
||||
@def __debugPromptShowDialog__
|
||||
@internal
|
||||
*/
|
||||
|
||||
#ifdef G3D_DEBUG
|
||||
|
||||
# if defined(_MSC_VER)
|
||||
# define rawBreak() ::DebugBreak();
|
||||
# elif defined(__i386__)
|
||||
// gcc on intel
|
||||
# define rawBreak() __asm__ __volatile__ ( "int $3" );
|
||||
# else
|
||||
// some other gcc
|
||||
# define rawBreak() ::abort()
|
||||
# endif
|
||||
// old mac code:
|
||||
//# define rawBreak() DebugStr((const unsigned char*)("\nG3D: Invoking breakpoint in debugger.")); /* XCode must be set to break on Debugger()/DebugStr() */
|
||||
|
||||
|
||||
# define debugBreak() G3D::_internal::_releaseInputGrab_(); rawBreak(); G3D::_internal::_restoreInputGrab_();
|
||||
# define debugAssert(exp) debugAssertM(exp, "Debug assertion failure")
|
||||
|
||||
#ifdef G3D_DEBUG_NOGUI
|
||||
#define __debugPromptShowDialog__ false
|
||||
#else
|
||||
#define __debugPromptShowDialog__ true
|
||||
#endif
|
||||
|
||||
#define debugAssertM(exp, message) do { \
|
||||
static bool __debugAssertIgnoreAlways__ = false; \
|
||||
if (!__debugAssertIgnoreAlways__ && !(exp)) { \
|
||||
G3D::_internal::_releaseInputGrab_(); \
|
||||
if ((G3D::_internal::_debugHook != NULL) && \
|
||||
G3D::_internal::_debugHook((const char*)(#exp), message, __FILE__, __LINE__, __debugAssertIgnoreAlways__, __debugPromptShowDialog__)) { \
|
||||
rawBreak(); \
|
||||
} \
|
||||
G3D::_internal::_restoreInputGrab_(); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define alwaysAssertM debugAssertM
|
||||
|
||||
#else // Release
|
||||
#ifdef G3D_DEBUG_NOGUI
|
||||
#define __debugPromptShowDialog__ false
|
||||
#else
|
||||
#define __debugPromptShowDialog__ true
|
||||
#endif
|
||||
|
||||
// In the release build, just define away assertions.
|
||||
#define rawBreak() do {} while (0)
|
||||
#define debugAssert(exp) do {} while (0)
|
||||
#define debugAssertM(exp, message) do {} while (0)
|
||||
#define debugBreak() do {} while (0)
|
||||
|
||||
// But keep the 'always' assertions
|
||||
#define alwaysAssertM(exp, message) { \
|
||||
static bool __alwaysAssertIgnoreAlways__ = false; \
|
||||
if (!__alwaysAssertIgnoreAlways__ && !(exp)) { \
|
||||
G3D::_internal::_releaseInputGrab_(); \
|
||||
if ((G3D::_internal::_failureHook != NULL) && \
|
||||
G3D::_internal::_failureHook(#exp, message, __FILE__, __LINE__, __alwaysAssertIgnoreAlways__, __debugPromptShowDialog__)) { \
|
||||
::exit(-1); \
|
||||
} \
|
||||
G3D::_internal::_restoreInputGrab_(); \
|
||||
} \
|
||||
}
|
||||
|
||||
#endif // if debug
|
||||
|
||||
|
||||
|
||||
namespace G3D { namespace _internal {
|
||||
|
||||
#ifdef G3D_LINUX
|
||||
/**
|
||||
A pointer to the X11 display. Initially NULL. If set to a
|
||||
non-null value (e.g. by SDLWindow), debugAssert attempts to use
|
||||
this display to release the mouse/input grab when an assertion
|
||||
fails.
|
||||
*/
|
||||
extern Display* x11Display;
|
||||
|
||||
/**
|
||||
A pointer to the X11 window. Initially NULL. If set to a
|
||||
non-null value (e.g. by SDLWindow), debugAssert attempts to use
|
||||
this window to release the mouse/input grab when an assertion
|
||||
fails.
|
||||
*/
|
||||
extern Window x11Window;
|
||||
#endif
|
||||
|
||||
/**
|
||||
Pops up an assertion dialog or prints an assertion
|
||||
|
||||
ignoreAlways - return result of pressing the ignore button.
|
||||
useGuiPrompt - if true, shows a dialog
|
||||
*/
|
||||
bool _handleDebugAssert_(
|
||||
const char* expression,
|
||||
const std::string& message,
|
||||
const char* filename,
|
||||
int lineNumber,
|
||||
bool& ignoreAlways,
|
||||
bool useGuiPrompt);
|
||||
|
||||
bool _handleErrorCheck_(
|
||||
const char* expression,
|
||||
const std::string& message,
|
||||
const char* filename,
|
||||
int lineNumber,
|
||||
bool& ignoreAlways,
|
||||
bool useGuiPrompt);
|
||||
|
||||
/** Attempts to give the user back their mouse and keyboard if they
|
||||
were locked to the current window.
|
||||
@internal*/
|
||||
void _releaseInputGrab_();
|
||||
|
||||
/** Attempts to restore the state before _releaseInputGrab_.
|
||||
@internal*/
|
||||
void _restoreInputGrab_();
|
||||
|
||||
}; }; // namespace
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
@file debugPrintf.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created 2001-08-26
|
||||
@edited 2007-07-20
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_DEBUGPRINTF_H
|
||||
#define G3D_DEBUGPRINTF_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <stdio.h>
|
||||
#include <cstdarg>
|
||||
#include "G3D/format.h"
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
typedef void (*ConsolePrintHook)(const std::string&);
|
||||
|
||||
namespace _internal {
|
||||
extern ConsolePrintHook _consolePrintHook;
|
||||
}
|
||||
|
||||
/** Called by consolePrintf after the log and terminal have been written to.
|
||||
Used by GConsole to intercept printing routines.*/
|
||||
void setConsolePrintHook(ConsolePrintHook h);
|
||||
|
||||
ConsolePrintHook consolePrintHook();
|
||||
|
||||
/**
|
||||
Sends output to the log and to the last GConsole instantiated.
|
||||
|
||||
Guarantees that the output has been flushed by the time the routine
|
||||
returns.
|
||||
@sa G3D::logPrintf, G3D::screenPrintf
|
||||
@return The string that was printed
|
||||
*/
|
||||
std::string __cdecl consolePrintf(const char* fmt ...) G3D_CHECK_PRINTF_ARGS;
|
||||
std::string consolePrint(const std::string&);
|
||||
|
||||
/**
|
||||
Under visual studio, appears in the VS debug pane.
|
||||
On unix-based operating systems the output is sent to stderr.
|
||||
|
||||
Also sends output to the console (G3D::consolePrintf) if there is a consolePrintHook,
|
||||
and log (G3D::logPrintf), and flushes before returning.
|
||||
|
||||
@return The string that was printed
|
||||
*/
|
||||
std::string __cdecl debugPrintf(const char* fmt ...) G3D_CHECK_PRINTF_ARGS;
|
||||
std::string debugPrint(const std::string&);
|
||||
|
||||
} // namespace G3D
|
||||
|
||||
#endif
|
||||
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
/**
|
||||
@file G3D/enumclass.h
|
||||
|
||||
@maintainer Morgan McGuire, morgan@graphics3d.com
|
||||
@created 2007-01-27
|
||||
@edited 2007-07-20
|
||||
*/
|
||||
#ifndef G3D_ENUMCLASS_H
|
||||
#define G3D_ENUMCLASS_H
|
||||
|
||||
#include "G3D/Table.h"
|
||||
#include "G3D/BinaryInput.h"
|
||||
#include "G3D/BinaryOutput.h"
|
||||
|
||||
/**
|
||||
Creates a series of methods that turn a class into a scoped enumeration.
|
||||
Uses the "Intelligent Enum" design pattern
|
||||
http://www.codeguru.com/cpp/cpp/cpp_mfc/article.php/c4001/
|
||||
|
||||
Enum classes are initialized to their zero value by default.
|
||||
|
||||
See GLG3D/GKey.h for an example.
|
||||
*/
|
||||
#define G3D_DECLARE_ENUM_CLASS_METHODS(Classname)\
|
||||
inline Classname(char v) : value((Value)v) {}\
|
||||
\
|
||||
inline Classname() : value((Value)0) {}\
|
||||
\
|
||||
inline Classname(const Value v) : value(v) {}\
|
||||
\
|
||||
explicit inline Classname(int v) : value((Value)v) {}\
|
||||
\
|
||||
/** Support cast back to the Value type, which is needed to allow implicit assignment inside unions. */\
|
||||
/*inline operator Value() const {
|
||||
return value;
|
||||
}*/\
|
||||
\
|
||||
inline operator int() const {\
|
||||
return (int)value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator== (const Classname other) const {\
|
||||
return value == other.value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator== (const Classname::Value other) const {\
|
||||
return value == other;\
|
||||
}\
|
||||
\
|
||||
inline bool operator!= (const Classname other) const {\
|
||||
return value != other.value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator!= (const Classname::Value other) const {\
|
||||
return value != other;\
|
||||
}\
|
||||
\
|
||||
inline bool operator< (const Classname other) const {\
|
||||
return value < other.value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator> (const Classname other) const {\
|
||||
return value > other.value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator>= (const Classname other) const {\
|
||||
return value >= other.value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator<= (const Classname other) const {\
|
||||
return value <= other.value;\
|
||||
}\
|
||||
\
|
||||
inline bool operator< (const Value other) const {\
|
||||
return value < other;\
|
||||
}\
|
||||
\
|
||||
inline bool operator> (const Value other) const {\
|
||||
return value > other;\
|
||||
}\
|
||||
\
|
||||
inline bool operator<= (const Value other) const {\
|
||||
return value <= other;\
|
||||
}\
|
||||
\
|
||||
inline bool operator>= (const Value other) const {\
|
||||
return value >= other;\
|
||||
}\
|
||||
\
|
||||
inline Classname& operator-- () {\
|
||||
value = (Value)((int)value - 1);\
|
||||
return *this;\
|
||||
}\
|
||||
\
|
||||
inline Classname& operator++ () {\
|
||||
value = (Value)((int)value + 1);\
|
||||
return *this;\
|
||||
}\
|
||||
\
|
||||
inline Classname& operator+= (const int x) {\
|
||||
value = (Value)((int)value + x);\
|
||||
return *this;\
|
||||
}\
|
||||
\
|
||||
inline Classname& operator-= (const int x) {\
|
||||
value = (Value)((int)value - x);\
|
||||
return *this;\
|
||||
}\
|
||||
\
|
||||
inline Classname operator+ (const int x) const {\
|
||||
return Classname((int)value + x);\
|
||||
}\
|
||||
\
|
||||
inline Classname operator- (const int x) const {\
|
||||
return Classname((int)value - x);\
|
||||
}\
|
||||
\
|
||||
inline unsigned int hashCode() const {\
|
||||
return (unsigned int)value;\
|
||||
}\
|
||||
\
|
||||
void serialize(BinaryOutput& b) const {\
|
||||
b.writeInt32(value);\
|
||||
}\
|
||||
\
|
||||
void deserialize(BinaryInput& b) {\
|
||||
value = (Value)b.readInt32();\
|
||||
}
|
||||
|
||||
#define G3D_DECLARE_ENUM_CLASS_HASHCODE(Classname)\
|
||||
template <> struct HashTrait<Classname::Value> \
|
||||
{ \
|
||||
static size_t hashCode(Classname::Value key) { return static_cast<size_t>(key); } \
|
||||
}; \
|
||||
\
|
||||
template <> struct HashTrait<Classname> \
|
||||
{ \
|
||||
static size_t hashCode(Classname key) { return static_cast<size_t>(key.hashCode()); } \
|
||||
};
|
||||
|
||||
#endif
|
||||
+246
@@ -0,0 +1,246 @@
|
||||
/**
|
||||
@file fileutils.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@author 2002-06-06
|
||||
@edited 2007-01-18
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_FILEUTILS_H
|
||||
#define G3D_FILEUTILS_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <string>
|
||||
#include <stdio.h>
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/Set.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
#ifdef G3D_WIN32
|
||||
// For chdir, mkdir, etc.
|
||||
# include <direct.h>
|
||||
#endif
|
||||
|
||||
namespace G3D {
|
||||
|
||||
namespace _internal {
|
||||
extern Set<std::string> currentFilesUsed;
|
||||
}
|
||||
|
||||
/** Returns all the files used by G3D and GLG3D during the current execution. */
|
||||
Array<std::string> filesUsed();
|
||||
|
||||
std::string readWholeFile(
|
||||
const std::string& filename);
|
||||
|
||||
|
||||
/** Reads from a zip file and decompresses the desired contents
|
||||
into memory. Does not support recursive zip calls (i.e. a .zip
|
||||
stored within another .zip)
|
||||
|
||||
@param file the path, of the format C:\...\something.zip\...\desiredfile.ext
|
||||
@param data a pointer to the memory where the file will be stored
|
||||
@param length the size of the file decompressed to memory */
|
||||
void zipRead(const std::string& file,
|
||||
void*& data,
|
||||
size_t& length);
|
||||
|
||||
|
||||
/** Closes the contents of a zip file that had been decompressed to
|
||||
memory. Must be called in tandem with zipRead() to avoid memory
|
||||
leaks.
|
||||
|
||||
@param data the pointer to the decompressed file in memory */
|
||||
void zipClose(void* data);
|
||||
|
||||
|
||||
/**
|
||||
@param flush If true (default), the file is ready for reading as soon
|
||||
as the function returns. If false, the function returns immediately and
|
||||
writes the file in the background.
|
||||
*/
|
||||
void writeWholeFile(
|
||||
const std::string& filename,
|
||||
const std::string& str,
|
||||
bool flush = true);
|
||||
|
||||
/**
|
||||
Creates the directory (which may optionally end in a /)
|
||||
and any parents needed to reach it.
|
||||
*/
|
||||
void createDirectory(
|
||||
const std::string& dir);
|
||||
|
||||
/**
|
||||
Fully qualifies a filename. The filename may contain wildcards,
|
||||
in which case the wildcards will be preserved in the returned value.
|
||||
*/
|
||||
std::string resolveFilename(const std::string& filename);
|
||||
|
||||
/**
|
||||
Appends all files matching filespec to the files array. The names
|
||||
will not contain paths unless includePath == true. These may be
|
||||
relative to the current directory unless the filespec is fully qualified
|
||||
(can be done with resolveFilename).
|
||||
Wildcards can only appear to the right of the last slash in filespec.
|
||||
Works with .zip files used as paths, if filespec is passed in the form
|
||||
C:\...\something.zip\* Does not work recursively with zipfiles (a
|
||||
.zip within a .zip will not work)
|
||||
*/
|
||||
void getFiles(
|
||||
const std::string& filespec,
|
||||
Array<std::string>& files,
|
||||
bool includePath = false);
|
||||
|
||||
/**
|
||||
Appends all directories matching filespec to the files array. The names
|
||||
will not contain paths unless includePath == true. These may be
|
||||
relative to the current directory unless the filespec is fully qualified
|
||||
(can be done with resolveFilename).
|
||||
Does not append special directories "." or "..".
|
||||
Works with .zip files used as paths, if filespec is passed in the form
|
||||
C:\...\something.zip\* Does not work recursively with zipfiles (a
|
||||
.zip within a .zip will not work)
|
||||
*/
|
||||
void getDirs(
|
||||
const std::string& filespec,
|
||||
Array<std::string>& files,
|
||||
bool includePath = false);
|
||||
|
||||
|
||||
/** Returns true if the specified path exists and is a directory */
|
||||
bool isDirectory(const std::string& filespec);
|
||||
|
||||
|
||||
/** Returns true if the specified filename exists and is a zipfile */
|
||||
bool isZipfile(const std::string& filename);
|
||||
|
||||
|
||||
/** Returns the length of the file. If
|
||||
filename specifies a path that contains a zipfile, but the
|
||||
contents within are specified correctly, returns the
|
||||
uncompressed size of the requested file. Returns -1 if
|
||||
the file does not exist.
|
||||
|
||||
@param filename the path to test, may contain .zip
|
||||
*/
|
||||
int64 fileLength(const std::string& filename);
|
||||
|
||||
/**
|
||||
Copies the file
|
||||
*/
|
||||
void copyFile(
|
||||
const std::string& source,
|
||||
const std::string& dest);
|
||||
|
||||
/** Returns a temporary file that is open for read/write access. This
|
||||
tries harder than the ANSI tmpfile, so it may succeed when that fails. */
|
||||
FILE* createTempFile();
|
||||
|
||||
/**
|
||||
Returns true if the given file (or directory) exists.
|
||||
|
||||
@param filename the path to test. must not end in a trailing slash.
|
||||
@param lookInZipfiles if the path does not exist, calls zipfileExists()
|
||||
*/
|
||||
bool fileExists(
|
||||
const std::string& filename,
|
||||
const bool lookInZipfiles = true);
|
||||
|
||||
/**
|
||||
Returns true if the given file (or directory) exists
|
||||
within a zipfile. Called if fileExists initially
|
||||
returns false and the lookInZipfiles flag has been set.
|
||||
Must not end in a trailing slash. Does not work for recursive
|
||||
zipfiles (.zips within another .zip)
|
||||
|
||||
@param filename the path to test
|
||||
@param outZipfile the path to the .zip file
|
||||
@param outInternalFile the path (within the .zip) where the desired file is located, if valid
|
||||
|
||||
*/
|
||||
bool zipfileExists(
|
||||
const std::string& filename,
|
||||
std::string& outZipfile,
|
||||
std::string& outInternalFile
|
||||
);
|
||||
|
||||
bool zipfileExists(const std::string& filename);
|
||||
|
||||
/**
|
||||
Parses a filename into four useful pieces.
|
||||
|
||||
Examples:
|
||||
|
||||
c:\a\b\d.e
|
||||
root = "c:\"
|
||||
path = "a" "b"
|
||||
base = "d"
|
||||
ext = "e"
|
||||
|
||||
/a/b/d.e
|
||||
root = "/"
|
||||
path = "a" "b"
|
||||
base = "d"
|
||||
ext = "e"
|
||||
|
||||
/a/b
|
||||
root = "/"
|
||||
path = "a"
|
||||
base = "b"
|
||||
ext = "e"
|
||||
|
||||
*/
|
||||
void parseFilename(
|
||||
const std::string& filename,
|
||||
std::string& drive,
|
||||
Array<std::string>& path,
|
||||
std::string& base,
|
||||
std::string& ext);
|
||||
|
||||
|
||||
/**
|
||||
Returns the part of the filename that includes the base and ext from
|
||||
parseFilename (i.e. everything to the right of the path).
|
||||
*/
|
||||
std::string filenameBaseExt(const std::string& filename);
|
||||
|
||||
/**
|
||||
Returns the extension on a filename.
|
||||
*/
|
||||
std::string filenameExt(const std::string& filename);
|
||||
|
||||
|
||||
/** Returns the portion of a filename to the left of the last period
|
||||
and to the right of the last slash or colon.
|
||||
*/
|
||||
std::string filenameBase(const std::string& filename);
|
||||
|
||||
/** Creates a unique filename base in the current directory using the
|
||||
specified prefix.*/
|
||||
std::string generateFilenameBase(const std::string& prefix = "");
|
||||
|
||||
/**
|
||||
Returns the drive (if Win32) and path from a filename, including
|
||||
a slash if there was one.
|
||||
<CODE>filenamePath(f) + filenameBaseExt(f) == f</CODE>
|
||||
*/
|
||||
std::string filenamePath(const std::string& filename);
|
||||
|
||||
/** Returns true if '*' or '?' appears in the string */
|
||||
bool filenameContainsWildcards(const std::string& filename);
|
||||
|
||||
/** Returns true if dst does not exist or src is newer than dst. Works on both files and directories. */
|
||||
bool fileIsNewer(const std::string& src, const std::string& dst);
|
||||
|
||||
/** Appends file onto dirname, ensuring a / if needed. */
|
||||
std::string pathConcat(const std::string& dirname, const std::string& file);
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
/**
|
||||
@file G3D/filter.h
|
||||
|
||||
@author Morgan McGuire, matrix@graphics3d.com
|
||||
@created 2007-03-01
|
||||
@edited 2007-03-01
|
||||
|
||||
Copyright 2000-2007, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
#ifndef G3D_FILTER_H
|
||||
#define G3D_FILTER_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
namespace G3D {
|
||||
/**
|
||||
Generates a set of 1D gaussian filter coefficients of size N. The coefficients
|
||||
are centered on element (N-1)/2 and have standard deviation given by std. The coefficients
|
||||
are normalized such that the sum across coeff is 1.0.
|
||||
|
||||
Matches the results returned by Matlab <code>fspecial('gaussian', [1, N], std)</code>
|
||||
*/
|
||||
void gaussian1D(Array<float>& coeff, int N = 5, float std = 0.5f);
|
||||
}
|
||||
|
||||
#endif
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
/**
|
||||
@file format.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@author 2000-09-09
|
||||
@edited 2005-11-03
|
||||
|
||||
Copyright 2000-2005, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_FORMAT_H
|
||||
#define G3D_FORMAT_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <string>
|
||||
#include <stdio.h>
|
||||
#include <cstdarg>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Produces a string from arguments of the style of printf. This avoids
|
||||
problems with buffer overflows when using sprintf and makes it easy
|
||||
to use the result functionally. This function is fast when the resulting
|
||||
string is under 160 characters (not including terminator) and slower
|
||||
when the string is longer.
|
||||
*/
|
||||
std::string __cdecl format(
|
||||
const char* fmt
|
||||
...) G3D_CHECK_PRINTF_ARGS;
|
||||
|
||||
/**
|
||||
Like format, but can be called with the argument list from a ... function.
|
||||
*/
|
||||
std::string vformat(
|
||||
const char* fmt,
|
||||
va_list argPtr) G3D_CHECK_VPRINTF_ARGS;
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
+810
@@ -0,0 +1,810 @@
|
||||
/**
|
||||
@file g3dmath.h
|
||||
|
||||
Math util class.
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
@cite highestBit by Jukka Liimatta
|
||||
|
||||
@created 2001-06-02
|
||||
@edited 2006-01-16
|
||||
|
||||
Copyright 2000-2006, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3DMATH_H
|
||||
#define G3DMATH_H
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// Disable conditional expression is constant, which occurs incorrectly on inlined functions
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable : 4127)
|
||||
// disable: "C++ exception handler used"
|
||||
# pragma warning (disable : 4530)
|
||||
#endif
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include <ctype.h>
|
||||
#include <float.h>
|
||||
#include <limits>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// Visual Studio is missing inttypes.h
|
||||
# ifndef PRId64
|
||||
# define PRId64 "I64d"
|
||||
# endif
|
||||
#else
|
||||
#include <inttypes.h>
|
||||
#endif
|
||||
|
||||
/*These defines enable functionality introduced with the 1999 ISO C
|
||||
**standard. They must be defined before the inclusion of math.h to
|
||||
**engage them. If optimisation is enabled, these functions will be
|
||||
**inlined. With optimisation switched off, you have to link in the
|
||||
**maths library using -lm.
|
||||
*/
|
||||
|
||||
#define _ISOC9X_SOURCE1
|
||||
#define _ISOC99_SOURCE1
|
||||
#define __USE_ISOC9X1
|
||||
#define __USE_ISOC991
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "G3D/debug.h"
|
||||
|
||||
#undef min
|
||||
#undef max
|
||||
|
||||
namespace G3D {
|
||||
|
||||
#ifdef _MSC_VER
|
||||
|
||||
/**
|
||||
Win32 implementation of the C99 fast rounding routines.
|
||||
|
||||
@cite routines are
|
||||
Copyright (C) 2001 Erik de Castro Lopo <erikd AT mega-nerd DOT com>
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this file for any
|
||||
purpose is hereby granted without fee, provided that the above copyright
|
||||
and this permission notice appear in all copies. No representations are
|
||||
made about the suitability of this software for any purpose. It is
|
||||
provided "as is" without express or implied warranty.
|
||||
*/
|
||||
|
||||
__inline long int lrint (double flt) {
|
||||
int intgr;
|
||||
|
||||
_asm {
|
||||
fld flt
|
||||
fistp intgr
|
||||
};
|
||||
|
||||
return intgr;
|
||||
}
|
||||
|
||||
__inline long int lrintf(float flt) {
|
||||
int intgr;
|
||||
|
||||
_asm {
|
||||
fld flt
|
||||
fistp intgr
|
||||
};
|
||||
|
||||
return intgr;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
const double fuzzyEpsilon = 0.00001;
|
||||
|
||||
/** Returns a reference to a static double.
|
||||
This value should not be tested against directly, instead
|
||||
G3D::isNan() and G3D::isFinite() will return reliable results. */
|
||||
inline const double& inf() {
|
||||
|
||||
// double is a standard type and should have infinity
|
||||
static const double i = std::numeric_limits<double>::infinity();
|
||||
return i;
|
||||
}
|
||||
|
||||
/** Returns a reference to a static double.
|
||||
This value should not be tested against directly, instead
|
||||
G3D::isNan() and G3D::isFinite() will return reliable results. */
|
||||
inline const double& nan() {
|
||||
|
||||
// double is a standard type and should have quiet NaN
|
||||
static const double n = std::numeric_limits<double>::quiet_NaN();
|
||||
return n;
|
||||
}
|
||||
|
||||
/** Returns a reference to a static double. Use instead of G3D_PI. */
|
||||
inline const double& pi() {
|
||||
static const double p = 3.1415926535898;
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Returns a reference to a static double. */
|
||||
inline const double& halfPi() {
|
||||
static const double p = pi() / 2.0;
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Returns a reference to a static double. */
|
||||
inline const double& twoPi() {
|
||||
static const double p = pi() * 2.0;;
|
||||
return p;
|
||||
}
|
||||
|
||||
typedef signed char int8;
|
||||
typedef unsigned char uint8;
|
||||
typedef short int16;
|
||||
typedef unsigned short uint16;
|
||||
typedef int int32;
|
||||
typedef unsigned int uint32;
|
||||
|
||||
#ifdef _MSC_EXTENSIONS
|
||||
typedef __int64 int64;
|
||||
typedef unsigned __int64 uint64;
|
||||
#elif ! defined(_MSC_VER)
|
||||
typedef int64_t int64;
|
||||
typedef uint64_t uint64;
|
||||
#else
|
||||
typedef long long int64;
|
||||
typedef unsigned long long uint64;
|
||||
#endif
|
||||
|
||||
typedef float float32;
|
||||
typedef double float64;
|
||||
|
||||
int iAbs(int iValue);
|
||||
int iCeil(double fValue);
|
||||
|
||||
/**
|
||||
Clamps the value to the range [low, hi] (inclusive)
|
||||
*/
|
||||
int iClamp(int val, int low, int hi);
|
||||
int16 iClamp(int16 val, int16 low, int16 hi);
|
||||
double clamp(double val, double low, double hi);
|
||||
float clamp(float val, float low, float hi);
|
||||
|
||||
/**
|
||||
Returns a + (b - a) * f;
|
||||
*/
|
||||
inline double lerp(double a, double b, double f) {
|
||||
return a + (b - a) * f;
|
||||
}
|
||||
|
||||
inline float lerp(float a, float b, float f) {
|
||||
return a + (b - a) * f;
|
||||
}
|
||||
|
||||
/**
|
||||
Wraps the value to the range [0, hi) (exclusive
|
||||
on the high end). This is like the clock arithmetic
|
||||
produced by % (modulo) except the result is guaranteed
|
||||
to be positive.
|
||||
*/
|
||||
int iWrap(int val, int hi);
|
||||
|
||||
int iFloor(double fValue);
|
||||
|
||||
int iSign(int iValue);
|
||||
int iSign(double fValue);
|
||||
|
||||
inline int iSign(float f) {
|
||||
return iSign((double)f);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Fast round to integer using the lrint routine.
|
||||
Typically 6x faster than casting to integer.
|
||||
*/
|
||||
inline int iRound(double fValue) {
|
||||
return lrint(fValue);
|
||||
}
|
||||
|
||||
/**
|
||||
Fast round to integer using the lrint routine.
|
||||
Typically 6x faster than casting to integer.
|
||||
*/
|
||||
inline int iRound(float f) {
|
||||
return lrintf(f);
|
||||
}
|
||||
|
||||
/**
|
||||
Returns a random number uniformly at random between low and hi
|
||||
(inclusive).
|
||||
*/
|
||||
int iRandom(int low, int hi);
|
||||
|
||||
double abs (double fValue);
|
||||
double aCos (double fValue);
|
||||
double aSin (double fValue);
|
||||
double aTan (double fValue);
|
||||
double aTan2 (double fY, double fX);
|
||||
double sign (double fValue);
|
||||
double square (double fValue);
|
||||
|
||||
/**
|
||||
Returns true if the argument is a finite real number.
|
||||
*/
|
||||
bool isFinite(double x);
|
||||
|
||||
/**
|
||||
Returns true if the argument is NaN (not a number).
|
||||
You can't use x == nan to test this because all
|
||||
comparisons against nan return false.
|
||||
*/
|
||||
bool isNaN(double x);
|
||||
|
||||
/**
|
||||
Computes x % 3.
|
||||
*/
|
||||
int iMod3(int x);
|
||||
|
||||
/**
|
||||
Uniform random number between low and hi, inclusive. [low, hi]
|
||||
*/
|
||||
float uniformRandom(float low = 0.0f, float hi = 1.0f);
|
||||
|
||||
/**
|
||||
Normally distributed random number.
|
||||
*/
|
||||
float gaussRandom(float mean = 0.0f, float stdev = 1.0f);
|
||||
|
||||
template <class T>
|
||||
inline T min(const T& x, const T& y) {
|
||||
return std::min<T>(x, y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T min(const T& x, const T& y, const T& z) {
|
||||
return std::min<T>(std::min<T>(x, y), z);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T min(const T& x, const T& y, const T& z, const T& w) {
|
||||
return std::min<T>(std::min<T>(x, y), std::min<T>(z, w));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T max(const T& x, const T& y) {
|
||||
return std::max<T>(x, y);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T max(const T& x, const T& y, const T& z) {
|
||||
return std::max<T>(std::max<T>(x, y), z);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
inline T max(const T& x, const T& y, const T& z, const T& w) {
|
||||
return std::max<T>(std::max<T>(x, y), std::max<T>(z, w));
|
||||
}
|
||||
|
||||
int iMin(int x, int y);
|
||||
int iMax(int x, int y);
|
||||
|
||||
double square(double x);
|
||||
double sumSquares(double x, double y);
|
||||
double sumSquares(double x, double y, double z);
|
||||
double distance(double x, double y);
|
||||
double distance(double x, double y, double z);
|
||||
|
||||
/**
|
||||
Returnes the 0-based index of the highest 1 bit from
|
||||
the left. -1 means the number was 0.
|
||||
|
||||
@cite Based on code by jukka@liimatta.org
|
||||
*/
|
||||
int highestBit(uint32 x);
|
||||
|
||||
/**
|
||||
Note that fuzzyEq(a, b) && fuzzyEq(b, c) does not imply
|
||||
fuzzyEq(a, c), although that will be the case on some
|
||||
occasions.
|
||||
*/
|
||||
bool fuzzyEq(double a, double b);
|
||||
|
||||
/** True if a is definitely not equal to b.
|
||||
Guaranteed false if a == b.
|
||||
Possibly false when a != b.*/
|
||||
bool fuzzyNe(double a, double b);
|
||||
|
||||
/** Is a strictly greater than b? (Guaranteed false if a <= b).
|
||||
(Possibly false if a > b) */
|
||||
bool fuzzyGt(double a, double b);
|
||||
|
||||
/** Is a near or greater than b? */
|
||||
bool fuzzyGe(double a, double b);
|
||||
|
||||
/** Is a strictly less than b? (Guaranteed false if a >= b)*/
|
||||
bool fuzzyLt(double a, double b);
|
||||
|
||||
/** Is a near or less than b? */
|
||||
bool fuzzyLe(double a, double b);
|
||||
|
||||
/**
|
||||
Computes 1 / sqrt(x).
|
||||
*/
|
||||
inline float rsq(float x) {
|
||||
return 1.0f / sqrtf(x);
|
||||
}
|
||||
|
||||
/**
|
||||
Uses SSE to implement rsq.
|
||||
@cite Nick nicolas@capens.net
|
||||
*/
|
||||
inline float SSErsq(float x) {
|
||||
|
||||
#if defined(SSE) && defined(G3D_WIN32)
|
||||
__asm {
|
||||
movss xmm0, x
|
||||
rsqrtss xmm0, xmm0
|
||||
movss x, xmm0
|
||||
}
|
||||
return x;
|
||||
#else
|
||||
return 1.0f / sqrt(x);
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
Return the next power of 2 higher than the input
|
||||
If the input is already a power of 2, the output will be the same
|
||||
as the input.
|
||||
*/
|
||||
int ceilPow2(unsigned int in);
|
||||
|
||||
/** Returns 2^x */
|
||||
inline int pow2(unsigned int x) {
|
||||
return 1 << x;
|
||||
}
|
||||
|
||||
|
||||
/** Log base 2 */
|
||||
inline float log2(float x) {
|
||||
return ::logf(x) / ::logf(2.0f);
|
||||
}
|
||||
|
||||
/** Log base 2 */
|
||||
inline double log2(double x) {
|
||||
return ::log(x) / ::log(2.0);
|
||||
}
|
||||
|
||||
/** Log base 2 */
|
||||
inline double log2(int x) {
|
||||
return log2((double)x);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* True if num is a power of two.
|
||||
*/
|
||||
bool isPow2(int num);
|
||||
|
||||
bool isOdd(int num);
|
||||
bool isEven(int num);
|
||||
|
||||
double toRadians(double deg);
|
||||
double toDegrees(double rad);
|
||||
|
||||
/**
|
||||
Returns true if x is not exactly equal to 0.0f.
|
||||
*/
|
||||
inline bool any(float x) {
|
||||
return x != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
Returns true if x is not exactly equal to 0.0f.
|
||||
*/
|
||||
inline bool all(float x) {
|
||||
return x != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
v / v (for DirectX/Cg support)
|
||||
*/
|
||||
inline float normalize(float v) {
|
||||
return v / v;
|
||||
}
|
||||
|
||||
/**
|
||||
a * b (for DirectX/Cg support)
|
||||
*/
|
||||
inline float dot(float a, float b) {
|
||||
return a * b;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
a * b (for DirectX/Cg support)
|
||||
*/
|
||||
inline float mul(float a, float b) {
|
||||
return a * b;
|
||||
}
|
||||
|
||||
/**
|
||||
2^x
|
||||
*/
|
||||
inline double exp2(double x) {
|
||||
return pow(2.0, x);
|
||||
}
|
||||
|
||||
inline double rsqrt(double x) {
|
||||
return 1.0 / sqrt(x);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
sin(x)/x
|
||||
*/
|
||||
inline double sinc(double x) {
|
||||
double r = sin(x) / x;
|
||||
|
||||
if (isNaN(r)) {
|
||||
return 1.0;
|
||||
} else {
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Computes a floating point modulo; the result is t wrapped to the range [lo, hi).
|
||||
*/
|
||||
inline float wrap(float t, float lo, float hi) {
|
||||
if ((t >= lo) && (t < hi)) {
|
||||
return t;
|
||||
}
|
||||
|
||||
debugAssert(hi > lo);
|
||||
|
||||
float interval = hi - lo;
|
||||
|
||||
return t - interval * iFloor((t - lo) / interval);
|
||||
}
|
||||
|
||||
|
||||
inline double wrap(double t, double lo, double hi) {
|
||||
if ((t >= lo) && (t < hi)) {
|
||||
return t;
|
||||
}
|
||||
|
||||
debugAssert(hi > lo);
|
||||
|
||||
double interval = hi - lo;
|
||||
|
||||
return t - interval * iFloor((t - lo) / interval);
|
||||
}
|
||||
|
||||
inline double wrap(double t, double hi) {
|
||||
return wrap(t, 0.0, hi);
|
||||
}
|
||||
|
||||
|
||||
inline bool isNaN(double x) {
|
||||
bool b1 = (x < 0.0);
|
||||
bool b2 = (x >= 0.0);
|
||||
bool b3 = !(b1 || b2);
|
||||
return b3;
|
||||
}
|
||||
|
||||
inline bool isFinite(double x) {
|
||||
return ! isNaN(x) && (x < G3D::inf()) && (x > -G3D::inf());
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline int iAbs (int iValue) {
|
||||
return ( iValue >= 0 ? iValue : -iValue );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline int iCeil (double fValue) {
|
||||
return int(::ceil(fValue));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline int iClamp(int val, int low, int hi) {
|
||||
debugAssert(low <= hi);
|
||||
if (val <= low) {
|
||||
return low;
|
||||
} else if (val >= hi) {
|
||||
return hi;
|
||||
} else {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline int16 iClamp(int16 val, int16 low, int16 hi) {
|
||||
debugAssert(low <= hi);
|
||||
if (val <= low) {
|
||||
return low;
|
||||
} else if (val >= hi) {
|
||||
return hi;
|
||||
} else {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline double clamp(double val, double low, double hi) {
|
||||
debugAssert(low <= hi);
|
||||
if (val <= low) {
|
||||
return low;
|
||||
} else if (val >= hi) {
|
||||
return hi;
|
||||
} else {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
inline float clamp(float val, float low, float hi) {
|
||||
debugAssert(low <= hi);
|
||||
if (val <= low) {
|
||||
return low;
|
||||
} else if (val >= hi) {
|
||||
return hi;
|
||||
} else {
|
||||
return val;
|
||||
}
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
inline int iWrap(int val, int hi) {
|
||||
if (val < 0) {
|
||||
return ((val % hi) + hi) % hi;
|
||||
} else {
|
||||
return val % hi;
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline int iFloor (double fValue) {
|
||||
return int(::floor(fValue));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline int iSign (int iValue) {
|
||||
return ( iValue > 0 ? + 1 : ( iValue < 0 ? -1 : 0 ) );
|
||||
}
|
||||
|
||||
inline int iSign (double fValue) {
|
||||
return ( fValue > 0.0 ? + 1 : ( fValue < 0.0 ? -1 : 0 ) );
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double abs (double fValue) {
|
||||
return double(::fabs(fValue));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double aCos (double fValue) {
|
||||
if ( -1.0 < fValue ) {
|
||||
if ( fValue < 1.0 )
|
||||
return double(::acos(fValue));
|
||||
else
|
||||
return 0.0;
|
||||
} else {
|
||||
return pi();
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double aSin (double fValue) {
|
||||
if ( -1.0 < fValue ) {
|
||||
if ( fValue < 1.0 ) {
|
||||
return double(::asin(fValue));
|
||||
} else {
|
||||
return -halfPi();
|
||||
}
|
||||
} else {
|
||||
return halfPi();
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double aTan (double fValue) {
|
||||
return double(::atan(fValue));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double aTan2 (double fY, double fX) {
|
||||
return double(::atan2(fY, fX));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double sign (double fValue) {
|
||||
if (fValue > 0.0) {
|
||||
return 1.0;
|
||||
}
|
||||
|
||||
if (fValue < 0.0) {
|
||||
return -1.0;
|
||||
}
|
||||
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
inline float sign (float fValue) {
|
||||
if (fValue > 0.0f) {
|
||||
return 1.0f;
|
||||
}
|
||||
|
||||
if (fValue < 0.0f) {
|
||||
return -1.0f;
|
||||
}
|
||||
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
|
||||
inline float uniformRandom(float low, float hi) {
|
||||
return (hi - low) * float(::rand()) / float(RAND_MAX) + low;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double square(double x) {
|
||||
return x * x;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double sumSquares(double x, double y) {
|
||||
return x*x + y*y;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double sumSquares(double x, double y, double z) {
|
||||
return x*x + y*y + z*z;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double distance(double x, double y) {
|
||||
return sqrt(sumSquares(x, y));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline double distance(double x, double y, double z) {
|
||||
return sqrt(sumSquares(x, y, z));
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
/** @deprecated use G3D::min */
|
||||
inline int iMin(int x, int y) {
|
||||
return (x >= y) ? y : x;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
/** @deprecated use G3D::min */
|
||||
inline int iMax(int x, int y) {
|
||||
return (x >= y) ? x : y;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
inline int ceilPow2(unsigned int in) {
|
||||
in -= 1;
|
||||
|
||||
in |= in >> 16;
|
||||
in |= in >> 8;
|
||||
in |= in >> 4;
|
||||
in |= in >> 2;
|
||||
in |= in >> 1;
|
||||
|
||||
return in + 1;
|
||||
}
|
||||
|
||||
inline bool isPow2(int num) {
|
||||
return ((num & -num) == num);
|
||||
}
|
||||
|
||||
inline bool isOdd(int num) {
|
||||
return (num & 1) == 1;
|
||||
}
|
||||
|
||||
inline bool isEven(int num) {
|
||||
return (num & 1) == 0;
|
||||
}
|
||||
|
||||
inline double toRadians(double deg) {
|
||||
return deg * pi() / 180.0;
|
||||
}
|
||||
|
||||
inline double toDegrees(double rad) {
|
||||
return rad * 180.0 / pi();
|
||||
}
|
||||
|
||||
inline float toRadians(float deg) {
|
||||
return deg * (float)pi() / 180.0f;
|
||||
}
|
||||
|
||||
inline float toDegrees(float rad) {
|
||||
return rad * 180.0f / (float)pi();
|
||||
}
|
||||
|
||||
inline float toRadians(int deg) {
|
||||
return deg * (float)pi() / 180.0f;
|
||||
}
|
||||
|
||||
inline float toDegrees(int rad) {
|
||||
return rad * 180.0f / (float)pi();
|
||||
}
|
||||
/**
|
||||
Computes an appropriate epsilon for comparing a and b.
|
||||
*/
|
||||
inline double eps(double a, double b) {
|
||||
// For a and b to be nearly equal, they must have nearly
|
||||
// the same magnitude. This means that we can ignore b
|
||||
// since it either has the same magnitude or the comparison
|
||||
// will fail anyway.
|
||||
(void)b;
|
||||
const double aa = abs(a) + 1;
|
||||
if (aa == inf()) {
|
||||
return fuzzyEpsilon;
|
||||
} else {
|
||||
return fuzzyEpsilon * aa;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool fuzzyEq(double a, double b) {
|
||||
return (a == b) || (abs(a - b) <= eps(a, b));
|
||||
}
|
||||
|
||||
inline bool fuzzyNe(double a, double b) {
|
||||
return ! fuzzyEq(a, b);
|
||||
}
|
||||
|
||||
inline bool fuzzyGt(double a, double b) {
|
||||
return a > b + eps(a, b);
|
||||
}
|
||||
|
||||
inline bool fuzzyGe(double a, double b) {
|
||||
return a > b - eps(a, b);
|
||||
}
|
||||
|
||||
inline bool fuzzyLt(double a, double b) {
|
||||
return a < b - eps(a, b);
|
||||
}
|
||||
|
||||
inline bool fuzzyLe(double a, double b) {
|
||||
return a < b + eps(a, b);
|
||||
}
|
||||
|
||||
inline int iMod3(int x) {
|
||||
return x % 3;
|
||||
}
|
||||
|
||||
/**
|
||||
Given a 32-bit integer, returns the integer with the bytes in the opposite order.
|
||||
*/
|
||||
inline uint32 flipEndian32(const uint32 x) {
|
||||
return (x << 24) | ((x & 0xFF00) << 8) |
|
||||
((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24);
|
||||
}
|
||||
|
||||
/**
|
||||
Given a 16-bit integer, returns the integer with the bytes in the opposite order.
|
||||
*/
|
||||
inline uint16 flipEndian16(const uint16 x) {
|
||||
return (x << 8) | ((x & 0xFF00) >> 8);
|
||||
}
|
||||
|
||||
|
||||
} // namespace
|
||||
|
||||
#ifdef _MSC_VER
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
+256
@@ -0,0 +1,256 @@
|
||||
/**
|
||||
@file platform.h
|
||||
|
||||
#defines for platform specific issues.
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created 2003-06-09
|
||||
@edited 2007-07-30
|
||||
*/
|
||||
|
||||
#ifndef G3D_PLATFORM_H
|
||||
#define G3D_PLATFORM_H
|
||||
|
||||
/**
|
||||
The version number of G3D in the form: MmmBB ->
|
||||
version M.mm [beta BB]
|
||||
*/
|
||||
#define G3D_VER 70100
|
||||
|
||||
#if defined(G3D_RELEASEDEBUG)
|
||||
# define G3D_DEBUGRELEASE
|
||||
#endif
|
||||
|
||||
#if defined(G3D_DEBUGRELEASE) && defined(_DEBUG)
|
||||
# undef _DEBUG
|
||||
#endif
|
||||
|
||||
#if !defined(G3D_DEBUG) && (defined(_DEBUG) || defined(G3D_DEBUGRELEASE))
|
||||
# define G3D_DEBUG
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define G3D_WIN32
|
||||
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
|
||||
#define G3D_FREEBSD
|
||||
#define G3D_LINUX
|
||||
#elif defined(__linux__)
|
||||
#define G3D_LINUX
|
||||
#elif defined(__APPLE__)
|
||||
#define G3D_OSX
|
||||
|
||||
// Prevent OS X fp.h header from being included; it defines
|
||||
// pi as a constant, which creates a conflict with G3D
|
||||
#define __FP__
|
||||
#else
|
||||
#error Unknown platform
|
||||
#endif
|
||||
|
||||
|
||||
// Default to compiling with SSE, but if you want to compile
|
||||
// without installing SP5.0 and the Processor Pack on Windows, compile with NO_SSE
|
||||
// defined (can be passed to the compiler command line with /D "NO_SSE")
|
||||
#if !defined(NO_SSE)
|
||||
#define SSE
|
||||
#endif
|
||||
|
||||
// On g++, recognize cases where the -msse2 flag was not specified
|
||||
#if defined(SSE) && defined(__GNUC__) && ! defined (__SSE__)
|
||||
# undef SSE
|
||||
#endif
|
||||
|
||||
|
||||
// Verify that the supported compilers are being used and that this is a known
|
||||
// processor.
|
||||
|
||||
#ifdef G3D_LINUX
|
||||
# ifndef __GNUC__
|
||||
# error G3D only supports the gcc compiler on Linux.
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef G3D_OSX
|
||||
# ifndef __GNUC__
|
||||
# error G3D only supports the gcc compiler on OS X.
|
||||
# endif
|
||||
|
||||
# if defined(__i386__)
|
||||
# define G3D_OSX_INTEL
|
||||
# elif defined(__PPC__)
|
||||
# define G3D_OSX_PPC
|
||||
# else
|
||||
# define G3D_OSX_UNKNOWN
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef _MSC_VER
|
||||
// Microsoft Visual C++ 8.0 ("Express") = 1400
|
||||
// Microsoft Visual C++ 7.1 ("2003") _MSC_VER = 1310
|
||||
// Microsoft Visual C++ 7.0 ("2002") _MSC_VER = 1300
|
||||
// Microsoft Visual C++ 6.0 _MSC_VER = 1200
|
||||
// Microsoft Visual C++ 5.0 _MSC_VER = 1100
|
||||
|
||||
// Turn off warnings about deprecated C routines (TODO: revisit)
|
||||
# pragma warning (disable : 4996)
|
||||
|
||||
// Turn off "conditional expression is constant" warning; MSVC generates this
|
||||
// for debug assertions in inlined methods.
|
||||
# pragma warning (disable : 4127)
|
||||
|
||||
# define G3D_DEPRECATED __declspec(deprecated)
|
||||
|
||||
// Prevent Winsock conflicts by hiding the winsock API
|
||||
# ifndef _WINSOCKAPI_
|
||||
# define _G3D_INTERNAL_HIDE_WINSOCK_
|
||||
# define _WINSOCKAPI_
|
||||
# endif
|
||||
|
||||
// Disable 'name too long for browse information' warning
|
||||
# pragma warning (disable : 4786)
|
||||
// TODO: remove
|
||||
# pragma warning (disable : 4244)
|
||||
|
||||
# define ZLIB_WINAPI
|
||||
|
||||
# define restrict
|
||||
|
||||
# define G3D_CHECK_PRINTF_ARGS
|
||||
# define G3D_CHECK_VPRINTF_ARGS
|
||||
# define G3D_CHECK_PRINTF_METHOD_ARGS
|
||||
# define G3D_CHECK_VPRINTF_METHOD_ARGS
|
||||
|
||||
// On MSVC, we need to link against the multithreaded DLL version of
|
||||
// the C++ runtime because that is what SDL and ZLIB are compiled
|
||||
// against. This is not the default for MSVC, so we set the following
|
||||
// defines to force correct linking.
|
||||
//
|
||||
// For documentation on compiler options, see:
|
||||
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vccore/html/_core_.2f.md.2c_2f.ml.2c_2f.mt.2c_2f.ld.asp
|
||||
// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vccore98/HTML/_core_Compiler_Reference.asp
|
||||
//
|
||||
|
||||
// DLL runtime
|
||||
#ifndef _DLL
|
||||
#define _DLL
|
||||
#endif
|
||||
|
||||
// Multithreaded runtime
|
||||
#ifndef _MT
|
||||
#define _MT 1
|
||||
#endif
|
||||
|
||||
// Ensure that we aren't forced into the static lib
|
||||
#ifdef _STATIC_CPPLIB
|
||||
#undef _STATIC_CPPLIB
|
||||
#endif
|
||||
|
||||
#ifdef _DEBUG
|
||||
#pragma comment (linker, "/NODEFAULTLIB:LIBCMTD.LIB")
|
||||
#pragma comment (linker, "/NODEFAULTLIB:LIBCPMTD.LIB")
|
||||
#pragma comment (linker, "/NODEFAULTLIB:LIBCPD.LIB")
|
||||
#pragma comment (linker, "/DEFAULTLIB:MSVCPRTD.LIB")
|
||||
#pragma comment(linker, "/NODEFAULTLIB:LIBCD.LIB")
|
||||
#pragma comment(linker, "/DEFAULTLIB:MSVCRTD.LIB")
|
||||
#else
|
||||
#pragma comment(linker, "/NODEFAULTLIB:LIBC.LIB")
|
||||
#pragma comment(linker, "/DEFAULTLIB:MSVCRT.LIB")
|
||||
#pragma comment (linker, "/NODEFAULTLIB:LIBCMT.LIB")
|
||||
#pragma comment (linker, "/NODEFAULTLIB:LIBCPMT.LIB")
|
||||
#pragma comment(linker, "/NODEFAULTLIB:LIBCP.LIB")
|
||||
#pragma comment (linker, "/DEFAULTLIB:MSVCPRT.LIB")
|
||||
#endif
|
||||
|
||||
// Now set up external linking
|
||||
|
||||
# ifdef _DEBUG
|
||||
// zlib was linked against the release MSVCRT; force
|
||||
// the debug version.
|
||||
# pragma comment(linker, "/NODEFAULTLIB:MSVCRT.LIB")
|
||||
# endif
|
||||
|
||||
|
||||
# ifndef WIN32_LEAN_AND_MEAN
|
||||
# define WIN32_LEAN_AND_MEAN 1
|
||||
# endif
|
||||
|
||||
|
||||
# define NOMINMAX 1
|
||||
# ifndef _WIN32_WINNT
|
||||
# define _WIN32_WINNT 0x0500
|
||||
# endif
|
||||
# include <windows.h>
|
||||
# undef WIN32_LEAN_AND_MEAN
|
||||
# undef NOMINMAX
|
||||
|
||||
# ifdef _G3D_INTERNAL_HIDE_WINSOCK_
|
||||
# undef _G3D_INTERNAL_HIDE_WINSOCK_
|
||||
# undef _WINSOCKAPI_
|
||||
# endif
|
||||
|
||||
|
||||
# define G3D_START_AT_MAIN()\
|
||||
int WINAPI G3D_WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw);\
|
||||
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR szCmdLine, int sw) {\
|
||||
return G3D_WinMain(hInst, hPrev, szCmdLine, sw);\
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
# define G3D_START_AT_MAIN()
|
||||
|
||||
#endif // win32
|
||||
|
||||
#ifdef __GNUC__
|
||||
|
||||
# include <stdint.h>
|
||||
|
||||
# if __STDC_VERSION__ < 199901
|
||||
# define restrict __restrict__
|
||||
# endif
|
||||
|
||||
# define G3D_DEPRECATED __attribute__((__deprecated__))
|
||||
|
||||
// setup function calling conventions
|
||||
# if defined(__i386__) && ! defined(__x86_64__)
|
||||
|
||||
# ifndef __cdecl
|
||||
# define __cdecl __attribute__((cdecl))
|
||||
# endif
|
||||
|
||||
# ifndef __stdcall
|
||||
# define __stdcall __attribute__((stdcall))
|
||||
# endif
|
||||
|
||||
# elif defined(__x86_64__) || defined(__powerpc__)
|
||||
|
||||
# ifndef __cdecl
|
||||
# define __cdecl
|
||||
# endif
|
||||
|
||||
# ifndef __stdcall
|
||||
# define __stdcall
|
||||
# endif
|
||||
# endif // calling conventions
|
||||
|
||||
# define G3D_CHECK_PRINTF_METHOD_ARGS __attribute__((__format__(__printf__, 2, 3)))
|
||||
# define G3D_CHECK_VPRINTF_METHOD_ARGS __attribute__((__format__(__printf__, 2, 0)))
|
||||
# define G3D_CHECK_PRINTF_ARGS __attribute__((__format__(__printf__, 1, 2)))
|
||||
# define G3D_CHECK_VPRINTF_ARGS __attribute__((__format__(__printf__, 1, 0)))
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
@def STR(expression)
|
||||
|
||||
Creates a string from the expression. Frequently used with G3D::Shader
|
||||
to express shading programs inline.
|
||||
|
||||
<CODE>STR(this becomes a string)<PRE> evaluates the same as <CODE>"this becomes a string"</CODE>
|
||||
*/
|
||||
#define STR(x) #x
|
||||
|
||||
// Header guard
|
||||
#endif
|
||||
+67
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
@file prompt.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
@cite Windows GUI code by Max McGuire
|
||||
|
||||
@created 2001-08-26
|
||||
@edited 2006-08-13
|
||||
*/
|
||||
|
||||
#ifndef G3D_PROMPT_H
|
||||
#define G3D_PROMPT_H
|
||||
|
||||
#include "platform.h"
|
||||
#include <string>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/**
|
||||
Prints a prompt to stdout and waits for user input. The return value is
|
||||
the number of the user's choice (the first is 0, if there are no
|
||||
choices, returns 0).
|
||||
|
||||
@param useGui Under Win32, use a GUI, not stdout prompt.
|
||||
@param windowTitle The title for the prompt window
|
||||
@param promptx The text string to prompt the user with
|
||||
@param choice An array of strings that are the choices the user may make
|
||||
@param numChoices The length of choice.
|
||||
|
||||
@cite Windows dialog interface by Max McGuire, mmcguire@ironlore.com
|
||||
@cite Font setting code by Kurt Miller, kurt@flipcode.com
|
||||
*/
|
||||
int prompt(
|
||||
const char* windowTitle,
|
||||
const char* promptx,
|
||||
const char** choice,
|
||||
int numChoices,
|
||||
bool useGui);
|
||||
|
||||
/**
|
||||
Prints a prompt and waits for user input. The return value is
|
||||
the number of the user's choice (the first is 0, if there are no
|
||||
choices, returns 0).
|
||||
<P>Uses GUI under Win32, stdout prompt otherwise.
|
||||
*/
|
||||
inline int prompt(
|
||||
const char* windowTitle,
|
||||
const char* promptx,
|
||||
const char** choice,
|
||||
int numChoices) {
|
||||
|
||||
return prompt(windowTitle, promptx, choice, numChoices, true);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Displays a GUI prompt with "Ok" as the only choice.
|
||||
*/
|
||||
void msgBox(
|
||||
const std::string& message,
|
||||
const std::string& title = "Message");
|
||||
|
||||
|
||||
}; // namespace
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
#ifndef G3D_SERIALIZE_H
|
||||
#define G3D_SERIALIZE_H
|
||||
|
||||
#include "G3D/BinaryInput.h"
|
||||
#include "G3D/BinaryOutput.h"
|
||||
#include "G3D/Array.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
|
||||
template<typename T>
|
||||
void serialize(const Array<T>& array, BinaryOutput& b) {
|
||||
b.writeInt32(array.size());
|
||||
for (int i = 0; i < array.size(); ++i) {
|
||||
serialize(array[i], b);
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void deserialize(Array<T>& array, BinaryInput& b) {
|
||||
int N = b.readInt32();
|
||||
array.resize(N);
|
||||
for (int i = 0; i < array.size(); ++i) {
|
||||
deserialize(array[i], b);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
+118
@@ -0,0 +1,118 @@
|
||||
/**
|
||||
@file spline.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created 2004-07-25
|
||||
@edited 2007-05-05
|
||||
*/
|
||||
|
||||
#ifndef G3D_SPLINEFUNC_H
|
||||
#define G3D_SPLINEFUNC_H
|
||||
|
||||
namespace G3D {
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/debug.h"
|
||||
#include "G3D/Array.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
/**
|
||||
Interpolates a property according to a piecewise linear spline. This provides
|
||||
C0 continuity but the derivatives are not smooth.
|
||||
<P>
|
||||
Example:
|
||||
<CODE>
|
||||
const double times[] = {MIDNIGHT, SUNRISE - HOUR, SUNRISE, SUNRISE + sunRiseAndSetTime / 4, SUNRISE + sunRiseAndSetTime, SUNSET - sunRiseAndSetTime, SUNSET - sunRiseAndSetTime / 2, SUNSET, SUNSET + HOUR/2, DAY};
|
||||
const Color3 color[] = {Color3(0, .0, .1), Color3(0, .0, .1), Color3::black(), Color3::black(), Color3::white() * .25, Color3::white() * .25, Color3(.5, .2, .2), Color3(.05, .05, .1), Color3(0, .0, .1), Color3(0, .0, .1)};
|
||||
ambient = linearSpline(time, times, color, 10);
|
||||
</CODE>
|
||||
|
||||
See also G3D::Spline
|
||||
|
||||
@param x The spline is a function of x; this is the sample to choose.
|
||||
@param controlX controlX[i], controlY[i] is a control points. It is assumed
|
||||
that controlX are strictly increasing. XType must support
|
||||
the "<" operator and a subtraction operator that returns
|
||||
a number.
|
||||
@param controlY YType must support multiplication and addition.
|
||||
@param numControl The number of control points.
|
||||
*/
|
||||
template<class XType, class YType>
|
||||
YType linearSpline(double x, const XType* controlX, const YType* controlY, int numControl) {
|
||||
debugAssert(numControl >= 1);
|
||||
|
||||
// Off the beginning
|
||||
if ((numControl == 1) || (x < controlX[0])) {
|
||||
return controlY[0];
|
||||
}
|
||||
|
||||
for (int i = 1; i < numControl; ++i) {
|
||||
if (x < controlX[i]) {
|
||||
const double alpha = (double)(controlX[i] - x) / (controlX[i] - controlX[i - 1]);
|
||||
return controlY[i] * (1 - alpha) + controlY[i - 1] * alpha;
|
||||
}
|
||||
}
|
||||
|
||||
// Off the end
|
||||
return controlY[numControl - 1];
|
||||
}
|
||||
|
||||
|
||||
/** See also G3D::Spline*/
|
||||
template<class YType> YType cyclicCatmullRomSpline(
|
||||
double t,
|
||||
const YType* controlY,
|
||||
int numPoints) {
|
||||
|
||||
debugAssert(numPoints >= 3);
|
||||
|
||||
t = wrap(t, numPoints);
|
||||
|
||||
// Find the indices of adjacent control points
|
||||
int i = iFloor(t);
|
||||
|
||||
// Compute the distance from the control point
|
||||
t = t - i;
|
||||
|
||||
// Shift back one point for correct indexing
|
||||
i += numPoints - 1;
|
||||
|
||||
// Pick up four control points
|
||||
const YType& P0 = controlY[(i + 0) % numPoints];
|
||||
const YType& P1 = controlY[(i + 1) % numPoints];
|
||||
const YType& P2 = controlY[(i + 2) % numPoints];
|
||||
const YType& P3 = controlY[(i + 3) % numPoints];
|
||||
|
||||
return 0.5 * ((2 * P1) +
|
||||
(-P0 + P2) * t +
|
||||
(2*P0 - 5*P1 + 4*P2 - P3) * t*t +
|
||||
(-P0 + 3*P1- 3*P2 + P3) * t*t*t);
|
||||
}
|
||||
|
||||
/**
|
||||
A cubic spline with regularly spaced
|
||||
control points. The spline interpolates
|
||||
the control points. The spline
|
||||
will wrap from the last point back to the first.
|
||||
|
||||
The t parameter is on the range [0, controlY.size()],
|
||||
where integers correspond to control points exactly.
|
||||
|
||||
See also G3D::Spline
|
||||
|
||||
@cite http://www.mvps.org/directx/articles/catmull/
|
||||
*/
|
||||
template<class YType> YType cyclicCatmullRomSpline(
|
||||
double t,
|
||||
const Array<YType>& controlY) {
|
||||
|
||||
int numPoints = controlY.size();
|
||||
return cyclicCatmullRomSpline(t, controlY.getCArray(), numPoints);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
/**
|
||||
@file stringutils.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@author 2000-09-09
|
||||
@edited 2008-08-05
|
||||
*/
|
||||
|
||||
#ifndef G3D_STRINGUTILS_H
|
||||
#define G3D_STRINGUTILS_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/Array.h"
|
||||
#include <cstring>
|
||||
|
||||
namespace G3D {
|
||||
|
||||
extern const char* NEWLINE;
|
||||
|
||||
/**
|
||||
Returns true if the test string begins with the pattern string.
|
||||
*/
|
||||
bool beginsWith(
|
||||
const std::string& test,
|
||||
const std::string& pattern);
|
||||
|
||||
/**
|
||||
Returns true if the test string ends with the pattern string.
|
||||
*/
|
||||
bool endsWith(
|
||||
const std::string& test,
|
||||
const std::string& pattern);
|
||||
|
||||
/**
|
||||
Produces a new string that is the input string
|
||||
wrapped at a certain number of columns (where
|
||||
the line is broken at the latest space before the
|
||||
column limit.) Platform specific NEWLINEs
|
||||
are inserted to wrap.
|
||||
*/
|
||||
std::string wordWrap(
|
||||
const std::string& input,
|
||||
int numCols);
|
||||
|
||||
/**
|
||||
A comparison function for passing to Array::sort.
|
||||
*/
|
||||
int stringCompare(
|
||||
const std::string& s1,
|
||||
const std::string& s2);
|
||||
|
||||
int stringPtrCompare(
|
||||
const std::string* s1,
|
||||
const std::string* s2);
|
||||
|
||||
/**
|
||||
Returns a new string that is an uppercase version of x.
|
||||
*/
|
||||
std::string toUpper(
|
||||
const std::string& x);
|
||||
|
||||
std::string toLower(
|
||||
const std::string& x);
|
||||
|
||||
/**
|
||||
Splits x at each occurance of splitChar.
|
||||
*/
|
||||
G3D::Array<std::string> stringSplit(
|
||||
const std::string& x,
|
||||
char splitChar);
|
||||
|
||||
/**
|
||||
joinChar is not inserted at the beginning or end, just in between
|
||||
elements.
|
||||
*/
|
||||
std::string stringJoin(
|
||||
const G3D::Array<std::string>& a,
|
||||
char joinChar);
|
||||
|
||||
std::string stringJoin(
|
||||
const G3D::Array<std::string>& a,
|
||||
const std::string& joinStr);
|
||||
|
||||
/**
|
||||
Strips whitespace from both ends of the string.
|
||||
*/
|
||||
std::string trimWhitespace(
|
||||
const std::string& s);
|
||||
|
||||
/** These standard C functions are renamed for clarity/naming
|
||||
conventions and to return bool, not int.
|
||||
*/
|
||||
inline bool isWhiteSpace(const unsigned char c) {
|
||||
return isspace(c) != 0;
|
||||
}
|
||||
|
||||
/** These standard C functions are renamed for clarity/naming
|
||||
conventions and to return bool, not int.
|
||||
*/
|
||||
inline bool isNewline(const unsigned char c) {
|
||||
return (c == '\n') || (c == '\r');
|
||||
}
|
||||
|
||||
/** These standard C functions are renamed for clarity/naming
|
||||
conventions and to return bool, not int.
|
||||
*/
|
||||
inline bool isDigit(const unsigned char c) {
|
||||
return isdigit(c) != 0;
|
||||
}
|
||||
|
||||
/** These standard C functions are renamed for clarity/naming
|
||||
conventions and to return bool, not int.
|
||||
*/
|
||||
inline bool isLetter(const unsigned char c) {
|
||||
return isalpha(c) != 0;
|
||||
}
|
||||
|
||||
inline bool isSlash(const unsigned char c) {
|
||||
return (c == '\\') || (c == '/');
|
||||
}
|
||||
|
||||
inline bool isQuote(const unsigned char c) {
|
||||
return (c == '\'') || (c == '\"');
|
||||
}
|
||||
|
||||
}; // namespace
|
||||
|
||||
#endif
|
||||
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
@file uint128.h
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
@author Kyle Whitson
|
||||
|
||||
@created 2008-07-17
|
||||
@edited 2008-07-17
|
||||
*/
|
||||
|
||||
#ifndef G3D_UINT128_H
|
||||
#define G3D_UINT128_H
|
||||
|
||||
#include "G3D/g3dmath.h"
|
||||
|
||||
namespace G3D {
|
||||
|
||||
/** Limited functionality 128-bit unsigned integer. This is primarily to support FNV hashing and other
|
||||
cryptography applications. See the GMP library for high-precision C++ math support. */
|
||||
class uint128 {
|
||||
public:
|
||||
|
||||
G3D::uint64 hi;
|
||||
G3D::uint64 lo;
|
||||
|
||||
uint128(const uint64& lo);
|
||||
|
||||
uint128(const uint64& hi, const uint64& lo);
|
||||
|
||||
uint128& operator+=(const uint128& x);
|
||||
|
||||
uint128& operator*=(const uint128& x);
|
||||
|
||||
uint128& operator^=(const uint128& x);
|
||||
|
||||
uint128& operator&=(const uint128& x);
|
||||
|
||||
uint128& operator|=(const uint128& x);
|
||||
|
||||
bool operator==(const uint128& x);
|
||||
|
||||
uint128& operator>>=(const int x);
|
||||
|
||||
uint128& operator<<=(const int x);
|
||||
|
||||
uint128 operator&(const uint128& x);
|
||||
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
+235
@@ -0,0 +1,235 @@
|
||||
/**
|
||||
@file vectorMath.h
|
||||
|
||||
Function aliases for popular vector methods.
|
||||
|
||||
@maintainer Morgan McGuire, matrix@graphics3d.com
|
||||
|
||||
@created: 2001-06-02
|
||||
@edited: 2004-02-02
|
||||
Copyright 2000-2004, Morgan McGuire.
|
||||
All rights reserved.
|
||||
*/
|
||||
|
||||
#ifndef G3D_VECTORMATH_H
|
||||
#define G3D_VECTORMATH_H
|
||||
|
||||
#include "G3D/platform.h"
|
||||
#include "G3D/g3dmath.h"
|
||||
#include "G3D/Vector2.h"
|
||||
#include "G3D/Vector3.h"
|
||||
#include "G3D/Vector4.h"
|
||||
#include "G3D/Matrix3.h"
|
||||
#include "G3D/Matrix4.h"
|
||||
#include "G3D/Color1.h"
|
||||
#include "G3D/Color3.h"
|
||||
#include "G3D/Color4.h"
|
||||
|
||||
|
||||
namespace G3D {
|
||||
|
||||
|
||||
inline Matrix4 mul(const Matrix4& a, const Matrix4& b) {
|
||||
return a * b;
|
||||
}
|
||||
|
||||
inline Vector4 mul(const Matrix4& m, const Vector4& v) {
|
||||
return m * v;
|
||||
}
|
||||
|
||||
inline Vector3 mul(const Matrix3& m, const Vector3& v) {
|
||||
return m * v;
|
||||
}
|
||||
|
||||
inline Matrix3 mul(const Matrix3& a, const Matrix3& b) {
|
||||
return a * b;
|
||||
}
|
||||
|
||||
inline float dot(const Vector2& a, const Vector2& b) {
|
||||
return a.dot(b);
|
||||
}
|
||||
|
||||
inline float dot(const Vector3& a, const Vector3& b) {
|
||||
return a.dot(b);
|
||||
}
|
||||
|
||||
inline float dot(const Vector4& a, const Vector4& b) {
|
||||
return a.dot(b);
|
||||
}
|
||||
|
||||
inline Vector2 normalize(const Vector2& v) {
|
||||
return v / v.length();
|
||||
}
|
||||
|
||||
inline Vector3 normalize(const Vector3& v) {
|
||||
return v / v.magnitude();
|
||||
}
|
||||
|
||||
inline Vector4 normalize(const Vector4& v) {
|
||||
return v / v.length();
|
||||
}
|
||||
|
||||
inline Vector2 abs(const Vector2& v) {
|
||||
return Vector2(::fabsf(v.x), ::fabsf(v.y));
|
||||
}
|
||||
|
||||
inline Vector3 abs(const Vector3& v) {
|
||||
return Vector3(::fabsf(v.x), ::fabsf(v.y), ::fabsf(v.z));
|
||||
}
|
||||
|
||||
inline Vector4 abs(const Vector4& v) {
|
||||
return Vector4(::fabsf(v.x), ::fabsf(v.y), ::fabsf(v.z), ::fabsf(v.w));
|
||||
}
|
||||
|
||||
inline bool all(const Vector2& v) {
|
||||
return (v.x != 0) && (v.y != 0);
|
||||
}
|
||||
|
||||
inline bool all(const Vector3& v) {
|
||||
return (v.x != 0) && (v.y != 0) && (v.z != 0);
|
||||
}
|
||||
|
||||
inline bool all(const Vector4& v) {
|
||||
return (v.x != 0) && (v.y != 0) && (v.z != 0) && (v.w != 0);
|
||||
}
|
||||
|
||||
inline bool any(const Vector2& v) {
|
||||
return (v.x != 0) || (v.y != 0);
|
||||
}
|
||||
|
||||
inline bool any(const Vector3& v) {
|
||||
return (v.x != 0) || (v.y != 0) || (v.z != 0);
|
||||
}
|
||||
|
||||
inline bool any(const Vector4& v) {
|
||||
return (v.x != 0) || (v.y != 0) || (v.z != 0) || (v.w != 0);
|
||||
}
|
||||
|
||||
inline Vector2 clamp(const Vector2& v, const Vector2& a, const Vector2& b) {
|
||||
return v.clamp(a, b);
|
||||
}
|
||||
|
||||
inline Vector3 clamp(const Vector3& v, const Vector3& a, const Vector3& b) {
|
||||
return v.clamp(a, b);
|
||||
}
|
||||
|
||||
inline Vector4 clamp(const Vector4& v, const Vector4& a, const Vector4& b) {
|
||||
return v.clamp(a, b);
|
||||
}
|
||||
|
||||
inline Vector2 lerp(const Vector2& v1, const Vector2& v2, float f) {
|
||||
return v1.lerp(v2, f);
|
||||
}
|
||||
|
||||
inline Vector3 lerp(const Vector3& v1, const Vector3& v2, float f) {
|
||||
return v1.lerp(v2, f);
|
||||
}
|
||||
|
||||
inline Vector4 lerp(const Vector4& v1, const Vector4& v2, float f) {
|
||||
return v1.lerp(v2, f);
|
||||
}
|
||||
|
||||
inline Color1 lerp(const Color1& v1, const Color1& v2, float f) {
|
||||
return v1.lerp(v2, f);
|
||||
}
|
||||
|
||||
inline Color3 lerp(const Color3& v1, const Color3& v2, float f) {
|
||||
return v1.lerp(v2, f);
|
||||
}
|
||||
|
||||
inline Color4 lerp(const Color4& v1, const Color4& v2, float f) {
|
||||
return v1.lerp(v2, f);
|
||||
}
|
||||
|
||||
inline Vector3 cross(const Vector3& v1, const Vector3& v2) {
|
||||
return v1.cross(v2);
|
||||
}
|
||||
|
||||
inline double determinant(const Matrix3& m) {
|
||||
return m.determinant();
|
||||
}
|
||||
|
||||
inline double determinant(const Matrix4& m) {
|
||||
return m.determinant();
|
||||
}
|
||||
|
||||
inline Vector2 min(const Vector2& v1, const Vector2& v2) {
|
||||
return v1.min(v2);
|
||||
}
|
||||
|
||||
inline Vector3 min(const Vector3& v1, const Vector3& v2) {
|
||||
return v1.min(v2);
|
||||
}
|
||||
|
||||
inline Vector4 min(const Vector4& v1, const Vector4& v2) {
|
||||
return v1.min(v2);
|
||||
}
|
||||
|
||||
inline Color3 min(const Color3& v1, const Color3& v2) {
|
||||
return v1.min(v2);
|
||||
}
|
||||
|
||||
inline Color4 min(const Color4& v1, const Color4& v2) {
|
||||
return v1.min(v2);
|
||||
}
|
||||
|
||||
inline Vector2 max(const Vector2& v1, const Vector2& v2) {
|
||||
return v1.max(v2);
|
||||
}
|
||||
|
||||
inline Vector3 max(const Vector3& v1, const Vector3& v2) {
|
||||
return v1.max(v2);
|
||||
}
|
||||
|
||||
inline Vector4 max(const Vector4& v1, const Vector4& v2) {
|
||||
return v1.max(v2);
|
||||
}
|
||||
|
||||
inline Color3 max(const Color3& v1, const Color3& v2) {
|
||||
return v1.max(v2);
|
||||
}
|
||||
|
||||
inline Color4 max(const Color4& v1, const Color4& v2) {
|
||||
return v1.max(v2);
|
||||
}
|
||||
|
||||
inline Vector2 sign(const Vector2& v) {
|
||||
return Vector2((float)sign(v.x), (float)sign(v.y));
|
||||
}
|
||||
|
||||
inline Vector3 sign(const Vector3& v) {
|
||||
return Vector3((float)sign(v.x), (float)sign(v.y), (float)sign(v.z));
|
||||
}
|
||||
|
||||
inline Vector4 sign(const Vector4& v) {
|
||||
return Vector4((float)sign(v.x), (float)sign(v.y), (float)sign(v.z), (float)sign(v.w));
|
||||
}
|
||||
|
||||
inline float length(float v) {
|
||||
return ::fabsf(v);
|
||||
}
|
||||
|
||||
inline float length(const Vector2& v) {
|
||||
return v.length();
|
||||
}
|
||||
|
||||
inline float length(const Vector3& v) {
|
||||
return v.magnitude();
|
||||
}
|
||||
|
||||
inline float length(const Vector4& v) {
|
||||
return v.length();
|
||||
}
|
||||
|
||||
/**
|
||||
Computes the log of each component. Useful for
|
||||
inverting the monitor gamma function or simulating
|
||||
perceptual response.
|
||||
*/
|
||||
inline Color3 log(const Color3& c) {
|
||||
return Color3(::logf(c.r), ::logf(c.g), ::logf(c.b));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user