/usr/include/libwildmagic/Wm5APoint.h is in libwildmagic-dev 5.13-1+b2.
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 | // Geometric Tools, LLC
// Copyright (c) 1998-2014
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 5.0.1 (2010/10/01)
#ifndef WM5APOINT_H
#define WM5APOINT_H
#include "Wm5MathematicsLIB.h"
#include "Wm5AVector.h"
namespace Wm5
{
class WM5_MATHEMATICS_ITEM APoint : public HPoint
{
public:
// Construction and destruction. APoint represents an affine point of the
// form (x,y,z,1). The destructor hides the HPoint destructor, which is
// not a problem because there are no side effects that must occur in the
// base class.
APoint (); // default (0,0,0,1)
APoint (const APoint& pnt);
APoint (float x, float y, float z);
APoint (const Float3& tuple);
APoint (const Vector3f& pnt);
~APoint ();
// Implicit conversions.
inline operator const Float3& () const;
inline operator Float3& ();
inline operator const Vector3f& () const;
inline operator Vector3f& ();
// Assignment.
APoint& operator= (const APoint& pnt);
// Arithmetic operations supported by affine algebra.
// A point minus a point is a vector.
AVector operator- (const APoint& pnt) const;
// A point plus or minus a vector is a point.
APoint operator+ (const AVector& vec) const;
APoint operator- (const AVector& vec) const;
APoint& operator+= (const AVector& vec);
APoint& operator-= (const AVector& vec);
// In affine algebra, points cannot be added arbitrarily. However,
// affine sums and affine differences are allowed. You are responsible
// for ensuring that you are computing one or the other.
//
// An affine sum is of the form
// r = s1*p1 + s2*p2 + ... + sn*pn
// where p1 through pn are homogeneous points (w-values are 1) and
// s1 through sn are scalars for which s1 + s2 + ... + sn = 1. The
// result r is a homogenous point.
//
// An affine difference is of the form
// r = d1*p1 + d2*p2 + ... + dn*pn
// where p1 through pn are homogeneous points (w-values are 1) and
// d1 through dn are scalars for which d1 + d2 + ... + dn = 0. The
// result r is a homogeneous vector. NOTE: The arithemtic operations
// of this class return APoint objects, but the affine difference needs
// to be an HVector object. The following code shows how to accomplish
// this:
// APoint p1, p2, p3; // initialized to whatever
// HVector r = 1.5f*p1 + (-0.2f)*p2 + (-0.3f)*p3;
// The right-hand side is computed using APoint operations, so it is an
// APoint object. HVector has a constructor that takes a 'const float*'.
// APoint has an implicit conversion to 'const float*'. The code
// APoint somePoint; // initialized to whatever
// HVector r = somePoint;
// involves an APoint implicit conversion to 'const float*' followed by
// an HVector(const float*) constructor call. The latter copies only the
// x, y, and z components and sets the w component to zero.
APoint operator+ (const APoint& pnt) const;
APoint operator* (float scalar) const;
APoint operator/ (float scalar) const;
WM5_MATHEMATICS_ITEM
friend APoint operator* (float scalar, const APoint& pnt);
APoint& operator+= (const APoint& pnt);
APoint& operator-= (const APoint& pnt);
APoint& operator*= (float scalar);
APoint& operator/= (float scalar);
APoint operator- () const;
// The dot product between a point and a vector is not allowed in affine
// algebra. However, it is convenient to have one defined when dealing
// with planes. Specifically, a plane is Dot(N,X-P) = 0, where N is a
// vector, P is a specific point on the plane, and X is any point on the
// plane. The difference X-P is a vector, so Dot(N,X-P) is well defined.
// If the plane is rewritten as Dot(N,X) = Dot(N,P), this is not supported
// by affine algebra, but we sometimes need to compute Dot(N,P) anyway.
// In the following, the w-component of the APoint is ignored, which means
// the APoint is treated as a vector.
float Dot (const AVector& vec) const;
// Special vector.
static const APoint ORIGIN; // (0,0,0,1)
};
#include "Wm5APoint.inl"
}
#endif
|