1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/**
@file Sphere.h
Sphere class
@maintainer Morgan McGuire, http://graphics.cs.williams.edu
@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;
bool contains(const Sphere& other) 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);
}
/** Sets this to the smallest sphere that encapsulates both */
void merge(const Sphere& s);
};
}
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
|
