Loading...
Searching...
No Matches
Ray.h
Go to the documentation of this file.
// Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0
/// @file Ray.h
///
/// @author Ken Museth
///
/// @brief A Ray class.
#ifndef NANOVDB_RAY_H_HAS_BEEN_INCLUDED
#define NANOVDB_RAY_H_HAS_BEEN_INCLUDED
#include <nanovdb/NanoVDB.h> // for Vec3
namespace nanovdb {
template<typename RealT>
class Ray
{
public:
using RealType = RealT;
using Vec3Type = Vec3<RealT>;
using Vec3T = Vec3Type;
struct TimeSpan
{
RealT t0, t1;
/// @brief Default constructor
__hostdev__ TimeSpan() {}
/// @brief Constructor
__hostdev__ TimeSpan(RealT _t0, RealT _t1)
: t0(_t0)
, t1(_t1)
{
}
/// @brief Set both times
__hostdev__ void set(RealT _t0, RealT _t1)
{
t0 = _t0;
t1 = _t1;
}
/// @brief Get both times
__hostdev__ void get(RealT& _t0, RealT& _t1) const
{
_t0 = t0;
_t1 = t1;
}
/// @brief Return @c true if t1 is larger than t0 by at least eps.
__hostdev__ bool valid(RealT eps = Delta<RealT>::value()) const { return (t1 - t0) > eps; }
/// @brief Return the midpoint of the ray.
__hostdev__ RealT mid() const { return 0.5 * (t0 + t1); }
/// @brief Multiplies both times
__hostdev__ void scale(RealT s)
{
assert(s > 0);
t0 *= s;
t1 *= s;
}
/// @brief Return @c true if time is inclusive
__hostdev__ bool test(RealT t) const { return (t >= t0 && t <= t1); }
};
__hostdev__ Ray(const Vec3Type& eye = Vec3Type(0, 0, 0),
const Vec3Type& direction = Vec3Type(1, 0, 0),
RealT t0 = Delta<RealT>::value(),
RealT t1 = Maximum<RealT>::value())
: mEye(eye)
, mDir(direction)
, mInvDir(1 / mDir[0], 1 / mDir[1], 1 / mDir[2])
, mTimeSpan(t0, t1)
, mSign{mInvDir[0] < 0, mInvDir[1] < 0, mInvDir[2] < 0}
{
}
__hostdev__ Ray& offsetEye(RealT offset)
{
mEye[0] += offset;
mEye[1] += offset;
mEye[2] += offset;
return *this;
}
__hostdev__ Ray& setEye(const Vec3Type& eye)
{
mEye = eye;
return *this;
}
__hostdev__ Ray& setDir(const Vec3Type& dir)
{
mDir = dir;
mInvDir[0] = 1.0 / mDir[0];
mInvDir[1] = 1.0 / mDir[1];
mInvDir[2] = 1.0 / mDir[2];
mSign[0] = mInvDir[0] < 0;
mSign[1] = mInvDir[1] < 0;
mSign[2] = mInvDir[2] < 0;
return *this;
}
__hostdev__ Ray& setMinTime(RealT t0)
{
mTimeSpan.t0 = t0;
return *this;
}
__hostdev__ Ray& setMaxTime(RealT t1)
{
mTimeSpan.t1 = t1;
return *this;
}
__hostdev__ Ray& setTimes(
RealT t0 = Delta<RealT>::value(),
RealT t1 = Maximum<RealT>::value())
{
assert(t0 > 0 && t1 > 0);
mTimeSpan.set(t0, t1);
return *this;
}
__hostdev__ Ray& scaleTimes(RealT scale)
{
mTimeSpan.scale(scale);
return *this;
}
__hostdev__ Ray& reset(
const Vec3Type& eye,
const Vec3Type& direction,
RealT t0 = Delta<RealT>::value(),
RealT t1 = Maximum<RealT>::value())
{
this->setEye(eye);
this->setDir(direction);
this->setTimes(t0, t1);
return *this;
}
__hostdev__ const Vec3T& eye() const { return mEye; }
__hostdev__ const Vec3T& dir() const { return mDir; }
__hostdev__ const Vec3T& invDir() const { return mInvDir; }
__hostdev__ RealT t0() const { return mTimeSpan.t0; }
__hostdev__ RealT t1() const { return mTimeSpan.t1; }
__hostdev__ int sign(int i) const { return mSign[i]; }
/// @brief Return the position along the ray at the specified time.
__hostdev__ Vec3T operator()(RealT time) const
{
#if 1
return Vec3T(fmaf(time, mDir[0], mEye[0]),
fmaf(time, mDir[1], mEye[1]),
fmaf(time, mDir[2], mEye[2]));
#else
return mEye + mDir * time;
#endif
}
/// @brief Return the starting point of the ray.
__hostdev__ Vec3T start() const { return (*this)(mTimeSpan.t0); }
/// @brief Return the endpoint of the ray.
__hostdev__ Vec3T end() const { return (*this)(mTimeSpan.t1); }
/// @brief Return the midpoint of the ray.
__hostdev__ Vec3T mid() const { return (*this)(mTimeSpan.mid()); }
/// @brief Return @c true if t1 is larger than t0 by at least eps.
__hostdev__ bool valid(RealT eps = Delta<float>::value()) const { return mTimeSpan.valid(eps); }
/// @brief Return @c true if @a time is within t0 and t1, both inclusive.
__hostdev__ bool test(RealT time) const { return mTimeSpan.test(time); }
/// @brief Return a new Ray that is transformed with the specified map.
///
/// @param map the map from which to construct the new Ray.
///
/// @warning Assumes a linear map and a normalized direction.
///
/// @details The requirement that the direction is normalized
/// follows from the transformation of t0 and t1 - and that fact that
/// we want applyMap and applyInverseMap to be inverse operations.
template<typename MapType>
__hostdev__ Ray applyMap(const MapType& map) const
{
const Vec3T eye = map.applyMap(mEye);
const Vec3T dir = map.applyJacobian(mDir);
const RealT length = dir.length(), invLength = RealT(1) / length;
RealT t1 = mTimeSpan.t1;
if (mTimeSpan.t1 < Maximum<RealT>::value()) {
t1 *= length;
}
return Ray(eye, dir * invLength, length * mTimeSpan.t0, t1);
}
template<typename MapType>
__hostdev__ Ray applyMapF(const MapType& map) const
{
const Vec3T eye = map.applyMapF(mEye);
const Vec3T dir = map.applyJacobianF(mDir);
const RealT length = dir.length(), invLength = RealT(1) / length;
RealT t1 = mTimeSpan.t1;
if (mTimeSpan.t1 < Maximum<RealT>::value()) {
t1 *= length;
}
return Ray(eye, dir * invLength, length * mTimeSpan.t0, t1);
}
/// @brief Return a new Ray that is transformed with the inverse of the specified map.
///
/// @param map the map from which to construct the new Ray by inverse mapping.
///
/// @warning Assumes a linear map and a normalized direction.
///
/// @details The requirement that the direction is normalized
/// follows from the transformation of t0 and t1 - and that fact that
/// we want applyMap and applyInverseMap to be inverse operations.
template<typename MapType>
__hostdev__ Ray applyInverseMap(const MapType& map) const
{
const Vec3T eye = map.applyInverseMap(mEye);
const Vec3T dir = map.applyInverseJacobian(mDir);
const RealT length = dir.length(), invLength = RealT(1) / length;
return Ray(eye, dir * invLength, length * mTimeSpan.t0, length * mTimeSpan.t1);
}
template<typename MapType>
__hostdev__ Ray applyInverseMapF(const MapType& map) const
{
const Vec3T eye = map.applyInverseMapF(mEye);
const Vec3T dir = map.applyInverseJacobianF(mDir);
const RealT length = dir.length(), invLength = RealT(1) / length;
return Ray(eye, dir * invLength, length * mTimeSpan.t0, length * mTimeSpan.t1);
}
/// @brief Return a new ray in world space, assuming the existing
/// ray is represented in the index space of the specified grid.
template<typename GridType>
__hostdev__ Ray indexToWorldF(const GridType& grid) const
{
const Vec3T eye = grid.indexToWorldF(mEye);
const Vec3T dir = grid.indexToWorldDirF(mDir);
const RealT length = dir.length(), invLength = RealT(1) / length;
RealT t1 = mTimeSpan.t1;
if (mTimeSpan.t1 < Maximum<RealT>::value()) {
t1 *= length;
}
return Ray(eye, dir * invLength, length * mTimeSpan.t0, t1);
}
/// @brief Return a new ray in index space, assuming the existing
/// ray is represented in the world space of the specified grid.
template<typename GridType>
__hostdev__ Ray worldToIndexF(const GridType& grid) const
{
const Vec3T eye = grid.worldToIndexF(mEye);
const Vec3T dir = grid.worldToIndexDirF(mDir);
const RealT length = dir.length(), invLength = RealT(1) / length;
RealT t1 = mTimeSpan.t1;
if (mTimeSpan.t1 < Maximum<RealT>::value()) {
t1 *= length;
}
return Ray(eye, dir * invLength, length * mTimeSpan.t0, t1);
}
/// @brief Return true if this ray intersects the specified sphere.
///
/// @param center The center of the sphere in the same space as this ray.
/// @param radius The radius of the sphere in the same units as this ray.
/// @param t0 The first intersection point if an intersection exists.
/// @param t1 The second intersection point if an intersection exists.
///
/// @note If the return value is true, i.e. a hit, and t0 =
/// this->t0() or t1 == this->t1() only one true intersection exist.
__hostdev__ bool intersects(const Vec3T& center, RealT radius, RealT& t0, RealT& t1) const
{
const Vec3T origin = mEye - center;
const RealT A = mDir.lengthSqr();
const RealT B = 2 * mDir.dot(origin);
const RealT C = origin.lengthSqr() - radius * radius;
const RealT D = B * B - 4 * A * C;
if (D < 0) {
return false;
}
const RealT Q = RealT(-0.5) * (B < 0 ? (B + Sqrt(D)) : (B - Sqrt(D)));
t0 = Q / A;
t1 = C / Q;
if (t0 > t1) {
RealT tmp = t0;
t0 = t1;
t1 = tmp;
}
if (t0 < mTimeSpan.t0) {
t0 = mTimeSpan.t0;
}
if (t1 > mTimeSpan.t1) {
t1 = mTimeSpan.t1;
}
return t0 <= t1;
}
/// @brief Return true if this ray intersects the specified sphere.
///
/// @param center The center of the sphere in the same space as this ray.
/// @param radius The radius of the sphere in the same units as this ray.
__hostdev__ bool intersects(const Vec3T& center, RealT radius) const
{
RealT t0, t1;
return this->intersects(center, radius, t0, t1) > 0;
}
/// @brief Return true if this ray intersects the specified sphere.
///
/// @note For intersection this ray is clipped to the two intersection points.
///
/// @param center The center of the sphere in the same space as this ray.
/// @param radius The radius of the sphere in the same units as this ray.
__hostdev__ bool clip(const Vec3T& center, RealT radius)
{
RealT t0, t1;
const bool hit = this->intersects(center, radius, t0, t1);
if (hit) {
mTimeSpan.set(t0, t1);
}
return hit;
}
#if 0
/// @brief Return true if the Ray intersects the specified
/// axisaligned bounding box.
///
/// @param bbox Axis-aligned bounding box in the same space as the Ray.
/// @param t0 If an intersection is detected this is assigned
/// the time for the first intersection point.
/// @param t1 If an intersection is detected this is assigned
/// the time for the second intersection point.
template<typename BBoxT>
__hostdev__ bool intersects(const BBoxT& bbox, RealT& t0, RealT& t1) const
{
t0 = (bbox[ mSign[0]][0] - mEye[0]) * mInvDir[0];
RealT t2 = (bbox[1-mSign[1]][1] - mEye[1]) * mInvDir[1];
if (t0 > t2) return false;
t1 = (bbox[1-mSign[0]][0] - mEye[0]) * mInvDir[0];
RealT t3 = (bbox[ mSign[1]][1] - mEye[1]) * mInvDir[1];
if (t3 > t1) return false;
if (t3 > t0) t0 = t3;
if (t2 < t1) t1 = t2;
t3 = (bbox[ mSign[2]][2] - mEye[2]) * mInvDir[2];
if (t3 > t1) return false;
t2 = (bbox[1-mSign[2]][2] - mEye[2]) * mInvDir[2];
if (t0 > t2) return false;
if (t3 > t0) t0 = t3;
if (mTimeSpan.t1 < t0) return false;
if (t2 < t1) t1 = t2;
if (mTimeSpan.t0 > t1) return false;
if (mTimeSpan.t0 > t0) t0 = mTimeSpan.t0;
if (mTimeSpan.t1 < t1) t1 = mTimeSpan.t1;
return true;
/*
mTimeSpan.get(_t0, _t1);
double t0 = _t0, t1 = _t1;
for (int i = 0; i < 3; ++i) {
//if (abs(mDir[i])<1e-3) continue;
double a = (double(bbox.min()[i]) - mEye[i]) * mInvDir[i];
double b = (double(bbox.max()[i]) - mEye[i]) * mInvDir[i];
if (a > b) {
double tmp = a;
a = b;
b = tmp;
}
if (a > t0) t0 = a;
if (b < t1) t1 = b;
if (t0 > t1) {
//if (gVerbose) printf("Missed BBOX: (%i,%i,%i) -> (%i,%i,%i) t0=%f t1=%f\n",
// bbox.min()[0], bbox.min()[1], bbox.min()[2],
// bbox.max()[0], bbox.max()[1], bbox.max()[2], t0, t1);
return false;
}
}
_t0 = t0; _t1 = t1;
return true;
*/
}
#else
/// @brief Returns true if this ray intersects an index bounding box.
/// If the return value is true t0 and t1 are set to the intersection
/// times along the ray.
///
/// @warning Intersection with a CoordBBox internally converts to a floating-point bbox
/// which imples that the max is padded with one voxel, i.e. bbox.max += 1! This
/// avoids gaps between neighboring CoordBBox'es, say from neighboring tree nodes.
__hostdev__ bool intersects(const CoordBBox& bbox, RealT& t0, RealT& t1) const
{
mTimeSpan.get(t0, t1);
for (int i = 0; i < 3; ++i) {
RealT a = RealT(bbox.min()[i]), b = RealT(bbox.max()[i] + 1);
if (a >= b) { // empty bounding box
return false;
}
a = (a - mEye[i]) * mInvDir[i];
b = (b - mEye[i]) * mInvDir[i];
if (a > b) {
RealT tmp = a;
a = b;
b = tmp;
}
if (a > t0) {
t0 = a;
}
if (b < t1) {
t1 = b;
}
if (t0 > t1) {
return false;
}
}
return true;
}
/// @brief Returns true if this ray intersects a floating-point bounding box.
/// If the return value is true t0 and t1 are set to the intersection
/// times along the ray.
template<typename OtherVec3T>
__hostdev__ bool intersects(const BBox<OtherVec3T>& bbox, RealT& t0, RealT& t1) const
{
static_assert(is_floating_point<typename OtherVec3T::ValueType>::value, "Ray::intersects: Expected a floating point coordinate");
mTimeSpan.get(t0, t1);
for (int i = 0; i < 3; ++i) {
RealT a = RealT(bbox.min()[i]), b = RealT(bbox.max()[i]);
if (a >= b) { // empty bounding box
return false;
}
a = (a - mEye[i]) * mInvDir[i];
b = (b - mEye[i]) * mInvDir[i];
if (a > b) {
RealT tmp = a;
a = b;
b = tmp;
}
if (a > t0) {
t0 = a;
}
if (b < t1) {
t1 = b;
}
if (t0 > t1) {
return false;
}
}
return true;
}
#endif
/// @brief Return true if this ray intersects the specified bounding box.
///
/// @param bbox Axis-aligned bounding box in the same space as this ray.
///
/// @warning If @a bbox is of the type CoordBBox it is converted to a floating-point
/// bounding box, which imples that the max is padded with one voxel, i.e.
/// bbox.max += 1! This avoids gaps between neighboring CoordBBox'es, say
/// from neighboring tree nodes.
template<typename BBoxT>
__hostdev__ bool intersects(const BBoxT& bbox) const
{
#if 1
RealT t0, t1;
return this->intersects(bbox, t0, t1);
#else
//BBox<Vec3T> bbox(Vec3T(_bbox[0][0]-1e-4,_bbox[0][1]-1e-4,_bbox[0][2]-1e-4),
// Vec3T(_bbox[1][0]+1e-4,_bbox[1][1]+1e-4,_bbox[1][2]+1e-4));
RealT t0 = (bbox[mSign[0]][0] - mEye[0]) * mInvDir[0];
RealT t2 = (bbox[1 - mSign[1]][1] - mEye[1]) * mInvDir[1];
if (t0 > t2) return false;
RealT t1 = (bbox[1 - mSign[0]][0] - mEye[0]) * mInvDir[0];
RealT t3 = (bbox[mSign[1]][1] - mEye[1]) * mInvDir[1];
if (t3 > t1) return false;
if (t3 > t0) t0 = t3;
if (t2 < t1) t1 = t2;
t3 = (bbox[mSign[2]][2] - mEye[2]) * mInvDir[2];
if (t3 > t1) return false;
t2 = (bbox[1 - mSign[2]][2] - mEye[2]) * mInvDir[2];
if (t0 > t2) return false;
//if (t3 > t0) t0 = t3;
//if (mTimeSpan.t1 < t0) return false;
//if (t2 < t1) t1 = t2;
//return mTimeSpan.t0 < t1;
return true;
#endif
}
/// @brief Return true if this ray intersects the specified bounding box.
///
/// @param bbox Axis-aligned bounding box in the same space as this ray.
///
/// @warning If @a bbox is of the type CoordBBox it is converted to a floating-point
/// bounding box, which imples that the max is padded with one voxel, i.e.
/// bbox.max += 1! This avoids gaps between neighboring CoordBBox'es, say
/// from neighboring tree nodes.
///
/// @note For intersection this ray is clipped to the two intersection points.
template<typename BBoxT>
__hostdev__ bool clip(const BBoxT& bbox)
{
RealT t0, t1;
const bool hit = this->intersects(bbox, t0, t1);
if (hit) {
mTimeSpan.set(t0, t1);
}
return hit;
}
/// @brief Return true if the Ray intersects the plane specified
/// by a normal and distance from the origin.
///
/// @param normal Normal of the plane.
/// @param distance Distance of the plane to the origin.
/// @param t Time of intersection, if one exists.
__hostdev__ bool intersects(const Vec3T& normal, RealT distance, RealT& t) const
{
const RealT cosAngle = mDir.dot(normal);
if (isApproxZero(cosAngle)) {
return false; // ray is parallel to plane
}
t = (distance - mEye.dot(normal)) / cosAngle;
return this->test(t);
}
/// @brief Return true if the Ray intersects the plane specified
/// by a normal and point.
///
/// @param normal Normal of the plane.
/// @param point Point in the plane.
/// @param t Time of intersection, if one exists.
__hostdev__ bool intersects(const Vec3T& normal, const Vec3T& point, RealT& t) const
{
return this->intersects(normal, point.dot(normal), t);
}
private:
Vec3T mEye, mDir, mInvDir;
TimeSpan mTimeSpan;
int mSign[3];
}; // end of Ray class
} // namespace nanovdb
#endif // NANOVDB_RAY_HAS_BEEN_INCLUDED
NanoVDB.h
Implements a light-weight self-contained VDB data-structure in a single file! In other words,...
__hostdev__
#define __hostdev__
Definition NanoVDB.h:213
nanovdb::Ray::clip
__hostdev__ bool clip(const Vec3T &center, RealT radius)
Return true if this ray intersects the specified sphere.
Definition Ray.h:324
nanovdb::Ray::Vec3Type
Vec3< RealT > Vec3Type
Definition Ray.h:22
nanovdb::Ray::setEye
__hostdev__ Ray & setEye(const Vec3Type &eye)
Definition Ray.h:83
nanovdb::Ray::intersects
__hostdev__ bool intersects(const Vec3T &center, RealT radius) const
Return true if this ray intersects the specified sphere.
Definition Ray.h:312
nanovdb::Ray::setDir
__hostdev__ Ray & setDir(const Vec3Type &dir)
Definition Ray.h:89
nanovdb::Ray::invDir
__hostdev__ const Vec3T & invDir() const
Definition Ray.h:144
nanovdb::Ray::end
__hostdev__ Vec3T end() const
Return the endpoint of the ray.
Definition Ray.h:168
nanovdb::Ray::intersects
__hostdev__ bool intersects(const BBox< OtherVec3T > &bbox, RealT &t0, RealT &t1) const
Returns true if this ray intersects a floating-point bounding box. If the return value is true t0 and...
Definition Ray.h:428
nanovdb::Ray::test
__hostdev__ bool test(RealT time) const
Return true if time is within t0 and t1, both inclusive.
Definition Ray.h:177
nanovdb::Ray::clip
__hostdev__ bool clip(const BBoxT &bbox)
Return true if this ray intersects the specified bounding box.
Definition Ray.h:506
nanovdb::Ray::sign
__hostdev__ int sign(int i) const
Definition Ray.h:150
nanovdb::Ray::Ray
__hostdev__ Ray(const Vec3Type &eye=Vec3Type(0, 0, 0), const Vec3Type &direction=Vec3Type(1, 0, 0), RealT t0=Delta< RealT >::value(), RealT t1=Maximum< RealT >::value())
Definition Ray.h:63
nanovdb::Ray::RealType
RealT RealType
Definition Ray.h:21
nanovdb::Ray::intersects
__hostdev__ bool intersects(const Vec3T &normal, RealT distance, RealT &t) const
Return true if the Ray intersects the plane specified by a normal and distance from the origin.
Definition Ray.h:522
nanovdb::Ray::setMinTime
__hostdev__ Ray & setMinTime(RealT t0)
Definition Ray.h:101
nanovdb::Ray::eye
__hostdev__ const Vec3T & eye() const
Definition Ray.h:140
nanovdb::Ray::applyInverseMap
__hostdev__ Ray applyInverseMap(const MapType &map) const
Return a new Ray that is transformed with the inverse of the specified map.
Definition Ray.h:223
nanovdb::Ray::Vec3T
Vec3Type Vec3T
Definition Ray.h:23
nanovdb::Ray::reset
__hostdev__ Ray & reset(const Vec3Type &eye, const Vec3Type &direction, RealT t0=Delta< RealT >::value(), RealT t1=Maximum< RealT >::value())
Definition Ray.h:128
nanovdb::Ray::offsetEye
__hostdev__ Ray & offsetEye(RealT offset)
Definition Ray.h:75
nanovdb::Ray::applyMap
__hostdev__ Ray applyMap(const MapType &map) const
Return a new Ray that is transformed with the specified map.
Definition Ray.h:189
nanovdb::Ray::setMaxTime
__hostdev__ Ray & setMaxTime(RealT t1)
Definition Ray.h:107
nanovdb::Ray::intersects
__hostdev__ bool intersects(const Vec3T &normal, const Vec3T &point, RealT &t) const
Return true if the Ray intersects the plane specified by a normal and point.
Definition Ray.h:538
nanovdb::Ray::dir
__hostdev__ const Vec3T & dir() const
Definition Ray.h:142
nanovdb::Ray::setTimes
__hostdev__ Ray & setTimes(RealT t0=Delta< RealT >::value(), RealT t1=Maximum< RealT >::value())
Definition Ray.h:113
nanovdb::Ray::t1
__hostdev__ RealT t1() const
Definition Ray.h:148
nanovdb::Ray::intersects
__hostdev__ bool intersects(const Vec3T &center, RealT radius, RealT &t0, RealT &t1) const
Return true if this ray intersects the specified sphere.
Definition Ray.h:278
nanovdb::Ray::applyInverseMapF
__hostdev__ Ray applyInverseMapF(const MapType &map) const
Definition Ray.h:231
nanovdb::Ray::valid
__hostdev__ bool valid(RealT eps=Delta< float >::value()) const
Return true if t1 is larger than t0 by at least eps.
Definition Ray.h:174
nanovdb::Ray::indexToWorldF
__hostdev__ Ray indexToWorldF(const GridType &grid) const
Return a new ray in world space, assuming the existing ray is represented in the index space of the s...
Definition Ray.h:242
nanovdb::Ray::t0
__hostdev__ RealT t0() const
Definition Ray.h:146
nanovdb::Ray::applyMapF
__hostdev__ Ray applyMapF(const MapType &map) const
Definition Ray.h:201
nanovdb::Ray::intersects
__hostdev__ bool intersects(const BBoxT &bbox) const
Return true if this ray intersects the specified bounding box.
Definition Ray.h:467
nanovdb::Ray::start
__hostdev__ Vec3T start() const
Return the starting point of the ray.
Definition Ray.h:165
nanovdb::Ray::intersects
__hostdev__ bool intersects(const CoordBBox &bbox, RealT &t0, RealT &t1) const
Returns true if this ray intersects an index bounding box. If the return value is true t0 and t1 are ...
Definition Ray.h:397
nanovdb::Ray::scaleTimes
__hostdev__ Ray & scaleTimes(RealT scale)
Definition Ray.h:122
nanovdb::Ray::operator()
__hostdev__ Vec3T operator()(RealT time) const
Return the position along the ray at the specified time.
Definition Ray.h:153
nanovdb::Ray::mid
__hostdev__ Vec3T mid() const
Return the midpoint of the ray.
Definition Ray.h:171
nanovdb::Ray::worldToIndexF
__hostdev__ Ray worldToIndexF(const GridType &grid) const
Return a new ray in index space, assuming the existing ray is represented in the world space of the s...
Definition Ray.h:257
nanovdb::Vec3
A simple vector class with three components, similar to openvdb::math::Vec3.
Definition NanoVDB.h:1530
nanovdb::Vec3::dot
T dot(const Vec3T &v) const
Definition NanoVDB.h:1575
nanovdb::Vec3::lengthSqr
T lengthSqr() const
Definition NanoVDB.h:1583
nanovdb
Definition NanoVDB.h:247
nanovdb::isApproxZero
bool isApproxZero(const Type &x)
Definition NanoVDB.h:1083
nanovdb::GridType
GridType
List of types that are currently supported by NanoVDB.
Definition NanoVDB.h:317
nanovdb::Sqrt
float Sqrt(float x)
Return the square root of a floating-point value.
Definition NanoVDB.h:1233
nanovdb::CoordBBox
BBox< Coord > CoordBBox
Definition NanoVDB.h:2535
nanovdb::BBox
Definition NanoVDB.h:2295
nanovdb::Delta
Delta for small floating-point offsets.
Definition NanoVDB.h:1035
nanovdb::Maximum::value
static T value()
Definition NanoVDB.h:1077
nanovdb::Ray::TimeSpan::set
__hostdev__ void set(RealT _t0, RealT _t1)
Set both times.
Definition Ray.h:37
nanovdb::Ray::TimeSpan::test
__hostdev__ bool test(RealT t) const
Return true if time is inclusive.
Definition Ray.h:60
nanovdb::Ray::TimeSpan::valid
__hostdev__ bool valid(RealT eps=Delta< RealT >::value()) const
Return true if t1 is larger than t0 by at least eps.
Definition Ray.h:49
nanovdb::Ray::TimeSpan::TimeSpan
__hostdev__ TimeSpan()
Default constructor.
Definition Ray.h:29
nanovdb::Ray::TimeSpan::mid
__hostdev__ RealT mid() const
Return the midpoint of the ray.
Definition Ray.h:51
nanovdb::Ray::TimeSpan::t1
RealT t1
Definition Ray.h:27
nanovdb::Ray::TimeSpan::TimeSpan
__hostdev__ TimeSpan(RealT _t0, RealT _t1)
Constructor.
Definition Ray.h:31
nanovdb::Ray::TimeSpan::t0
RealT t0
Definition Ray.h:27
nanovdb::Ray::TimeSpan::get
__hostdev__ void get(RealT &_t0, RealT &_t1) const
Get both times.
Definition Ray.h:43
nanovdb::Ray::TimeSpan::scale
__hostdev__ void scale(RealT s)
Multiplies both times.
Definition Ray.h:53
nanovdb::is_floating_point::value
static constexpr bool value
Definition NanoVDB.h:464