/usr/include/irrlicht/plane3d.h is in libirrlicht-dev 1.8.1+dfsg1-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 | // Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __IRR_PLANE_3D_H_INCLUDED__
#define __IRR_PLANE_3D_H_INCLUDED__
#include "irrMath.h"
#include "vector3d.h"
namespace irr
{
namespace core
{
//! Enumeration for intersection relations of 3d objects
enum EIntersectionRelation3D
{
ISREL3D_FRONT = 0,
ISREL3D_BACK,
ISREL3D_PLANAR,
ISREL3D_SPANNING,
ISREL3D_CLIPPED
};
//! Template plane class with some intersection testing methods.
/** It has to be ensured, that the normal is always normalized. The constructors
and setters of this class will not ensure this automatically. So any normal
passed in has to be normalized in advance. No change to the normal will be
made by any of the class methods.
*/
template <class T>
class plane3d
{
public:
// Constructors
plane3d(): Normal(0,1,0) { recalculateD(vector3d<T>(0,0,0)); }
plane3d(const vector3d<T>& MPoint, const vector3d<T>& Normal) : Normal(Normal) { recalculateD(MPoint); }
plane3d(T px, T py, T pz, T nx, T ny, T nz) : Normal(nx, ny, nz) { recalculateD(vector3d<T>(px, py, pz)); }
plane3d(const vector3d<T>& point1, const vector3d<T>& point2, const vector3d<T>& point3)
{ setPlane(point1, point2, point3); }
plane3d(const vector3d<T> & normal, const T d) : Normal(normal), D(d) { }
// operators
inline bool operator==(const plane3d<T>& other) const { return (equals(D, other.D) && Normal==other.Normal);}
inline bool operator!=(const plane3d<T>& other) const { return !(*this == other);}
// functions
void setPlane(const vector3d<T>& point, const vector3d<T>& nvector)
{
Normal = nvector;
recalculateD(point);
}
void setPlane(const vector3d<T>& nvect, T d)
{
Normal = nvect;
D = d;
}
void setPlane(const vector3d<T>& point1, const vector3d<T>& point2, const vector3d<T>& point3)
{
// creates the plane from 3 memberpoints
Normal = (point2 - point1).crossProduct(point3 - point1);
Normal.normalize();
recalculateD(point1);
}
//! Get an intersection with a 3d line.
/** \param lineVect Vector of the line to intersect with.
\param linePoint Point of the line to intersect with.
\param outIntersection Place to store the intersection point, if there is one.
\return True if there was an intersection, false if there was not.
*/
bool getIntersectionWithLine(const vector3d<T>& linePoint,
const vector3d<T>& lineVect,
vector3d<T>& outIntersection) const
{
T t2 = Normal.dotProduct(lineVect);
if (t2 == 0)
return false;
T t =- (Normal.dotProduct(linePoint) + D) / t2;
outIntersection = linePoint + (lineVect * t);
return true;
}
//! Get percentage of line between two points where an intersection with this plane happens.
/** Only useful if known that there is an intersection.
\param linePoint1 Point1 of the line to intersect with.
\param linePoint2 Point2 of the line to intersect with.
\return Where on a line between two points an intersection with this plane happened.
For example, 0.5 is returned if the intersection happened exactly in the middle of the two points.
*/
f32 getKnownIntersectionWithLine(const vector3d<T>& linePoint1,
const vector3d<T>& linePoint2) const
{
vector3d<T> vect = linePoint2 - linePoint1;
T t2 = (f32)Normal.dotProduct(vect);
return (f32)-((Normal.dotProduct(linePoint1) + D) / t2);
}
//! Get an intersection with a 3d line, limited between two 3d points.
/** \param linePoint1 Point 1 of the line.
\param linePoint2 Point 2 of the line.
\param outIntersection Place to store the intersection point, if there is one.
\return True if there was an intersection, false if there was not.
*/
bool getIntersectionWithLimitedLine(
const vector3d<T>& linePoint1,
const vector3d<T>& linePoint2,
vector3d<T>& outIntersection) const
{
return (getIntersectionWithLine(linePoint1, linePoint2 - linePoint1, outIntersection) &&
outIntersection.isBetweenPoints(linePoint1, linePoint2));
}
//! Classifies the relation of a point to this plane.
/** \param point Point to classify its relation.
\return ISREL3D_FRONT if the point is in front of the plane,
ISREL3D_BACK if the point is behind of the plane, and
ISREL3D_PLANAR if the point is within the plane. */
EIntersectionRelation3D classifyPointRelation(const vector3d<T>& point) const
{
const T d = Normal.dotProduct(point) + D;
if (d < -ROUNDING_ERROR_f32)
return ISREL3D_BACK;
if (d > ROUNDING_ERROR_f32)
return ISREL3D_FRONT;
return ISREL3D_PLANAR;
}
//! Recalculates the distance from origin by applying a new member point to the plane.
void recalculateD(const vector3d<T>& MPoint)
{
D = - MPoint.dotProduct(Normal);
}
//! Gets a member point of the plane.
vector3d<T> getMemberPoint() const
{
return Normal * -D;
}
//! Tests if there is an intersection with the other plane
/** \return True if there is a intersection. */
bool existsIntersection(const plane3d<T>& other) const
{
vector3d<T> cross = other.Normal.crossProduct(Normal);
return cross.getLength() > core::ROUNDING_ERROR_f32;
}
//! Intersects this plane with another.
/** \param other Other plane to intersect with.
\param outLinePoint Base point of intersection line.
\param outLineVect Vector of intersection.
\return True if there is a intersection, false if not. */
bool getIntersectionWithPlane(const plane3d<T>& other,
vector3d<T>& outLinePoint,
vector3d<T>& outLineVect) const
{
const T fn00 = Normal.getLength();
const T fn01 = Normal.dotProduct(other.Normal);
const T fn11 = other.Normal.getLength();
const f64 det = fn00*fn11 - fn01*fn01;
if (fabs(det) < ROUNDING_ERROR_f64 )
return false;
const f64 invdet = 1.0 / det;
const f64 fc0 = (fn11*-D + fn01*other.D) * invdet;
const f64 fc1 = (fn00*-other.D + fn01*D) * invdet;
outLineVect = Normal.crossProduct(other.Normal);
outLinePoint = Normal*(T)fc0 + other.Normal*(T)fc1;
return true;
}
//! Get the intersection point with two other planes if there is one.
bool getIntersectionWithPlanes(const plane3d<T>& o1,
const plane3d<T>& o2, vector3d<T>& outPoint) const
{
vector3d<T> linePoint, lineVect;
if (getIntersectionWithPlane(o1, linePoint, lineVect))
return o2.getIntersectionWithLine(linePoint, lineVect, outPoint);
return false;
}
//! Test if the triangle would be front or backfacing from any point.
/** Thus, this method assumes a camera position from
which the triangle is definitely visible when looking into
the given direction.
Note that this only works if the normal is Normalized.
Do not use this method with points as it will give wrong results!
\param lookDirection: Look direction.
\return True if the plane is front facing and
false if it is backfacing. */
bool isFrontFacing(const vector3d<T>& lookDirection) const
{
const f32 d = Normal.dotProduct(lookDirection);
return F32_LOWER_EQUAL_0 ( d );
}
//! Get the distance to a point.
/** Note that this only works if the normal is normalized. */
T getDistanceTo(const vector3d<T>& point) const
{
return point.dotProduct(Normal) + D;
}
//! Normal vector of the plane.
vector3d<T> Normal;
//! Distance from origin.
T D;
};
//! Typedef for a f32 3d plane.
typedef plane3d<f32> plane3df;
//! Typedef for an integer 3d plane.
typedef plane3d<s32> plane3di;
} // end namespace core
} // end namespace irr
#endif
|