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
|
/**
@file Ray.cpp
@maintainer Morgan McGuire, matrix@graphics3d.com
@created 2002-07-12
@edited 2004-03-19
*/
#include "G3D/platform.h"
#include "G3D/Ray.h"
#include "G3D/Plane.h"
#include "G3D/Sphere.h"
#include "G3D/CollisionDetection.h"
namespace G3D {
Ray::Ray(class BinaryInput& b) {
deserialize(b);
}
void Ray::serialize(class BinaryOutput& b) const {
origin.serialize(b);
direction.serialize(b);
}
void Ray::deserialize(class BinaryInput& b) {
origin.deserialize(b);
direction.deserialize(b);
}
Ray Ray::refract(
const Vector3& newOrigin,
const Vector3& normal,
float iInside,
float iOutside) const {
Vector3 D = direction.refractionDirection(normal, iInside, iOutside);
return Ray::fromOriginAndDirection(
newOrigin + (direction + normal * (float)sign(direction.dot(normal))) * 0.001f, D);
}
Ray Ray::reflect(
const Vector3& newOrigin,
const Vector3& normal) const {
Vector3 D = direction.reflectionDirection(normal);
return Ray::fromOriginAndDirection(newOrigin + (D + normal) * 0.001f, D);
}
Vector3 Ray::intersection(const Plane& plane) const {
float d;
Vector3 normal = plane.normal();
plane.getEquation(normal, d);
float rate = direction.dot(normal);
if (rate >= 0.0f) {
return Vector3::inf();
} else {
float t = -(d + origin.dot(normal)) / rate;
return origin + direction * t;
}
}
float Ray::intersectionTime(const class Sphere& sphere) const {
Vector3 dummy;
return CollisionDetection::collisionTimeForMovingPointFixedSphere(
origin, direction, sphere, dummy);
}
float Ray::intersectionTime(const class Plane& plane) const {
Vector3 dummy;
return CollisionDetection::collisionTimeForMovingPointFixedPlane(
origin, direction, plane, dummy);
}
float Ray::intersectionTime(const class Box& box) const {
Vector3 dummy;
float time = CollisionDetection::collisionTimeForMovingPointFixedBox(
origin, direction, box, dummy);
if ((time == inf()) && (box.contains(origin))) {
return 0.0f;
} else {
return time;
}
}
float Ray::intersectionTime(const class AABox& box) const {
Vector3 dummy;
bool inside;
float time = CollisionDetection::collisionTimeForMovingPointFixedAABox(
origin, direction, box, dummy, inside);
if ((time == inf()) && inside) {
return 0.0f;
} else {
return time;
}
}
}
|
