ray.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_BASE_GF_RAY_H
#define PXR_BASE_GF_RAY_H
 
 
#include "pxr/pxr.h"
#include "pxr/base/gf/matrix4d.h"
#include "pxr/base/gf/api.h"
 
#include <float.h>
#include <limits>
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class GfBBox3d;
class GfLine;
class GfLineSeg;
class GfPlane;
class GfRange3d;
 
class GfRay {
 
  public:
 
    GfRay() {
    }
 
    GfRay(const GfVec3d &startPoint, const GfVec3d &direction) {
        SetPointAndDirection(startPoint, direction);
    }
 
    GF_API
    void        SetPointAndDirection(const GfVec3d &startPoint,
                                     const GfVec3d &direction);
 
    GF_API
    void        SetEnds(const GfVec3d &startPoint, const GfVec3d &endPoint);
 
    const GfVec3d &     GetStartPoint() const {
        return _startPoint;
    }
 
    const GfVec3d &     GetDirection() const {
        return _direction;
    }
 
    GfVec3d             GetPoint(double distance) const {
        return _startPoint + distance * _direction;
    }
 
    GF_API
    GfRay &     Transform(const GfMatrix4d &matrix);
 
    GF_API
    GfVec3d             FindClosestPoint(const GfVec3d &point,
                                         double *rayDistance = NULL) const;
 
    bool                operator ==(const GfRay &r) const {
        return (_startPoint == r._startPoint &&
                _direction  == r._direction);
    }
 
    bool                operator !=(const GfRay &r) const {
        return ! (*this == r);
    }
 
 
    GF_API
    bool    Intersect(const GfVec3d &p0,
                      const GfVec3d &p1,
                      const GfVec3d &p2,
                      double *distance = NULL,
                      GfVec3d *barycentricCoords = NULL,
                      bool *frontFacing = NULL,
                      double maxDist = std::numeric_limits<double>::infinity())
                      const;
 
    GF_API
    bool        Intersect(const GfPlane &plane, double *distance = NULL,
                          bool *frontFacing = NULL) const;
 
    GF_API
    bool        Intersect(const GfRange3d &box,
                          double *enterDistance = NULL,
                          double *exitDistance = NULL) const;
 
    GF_API
    bool        Intersect(const GfBBox3d &box,
                          double *enterDistance = NULL,
                          double *exitDistance = NULL) const;
 
    GF_API
    bool        Intersect(const GfVec3d &center, double radius,
                          double *enterDistance = NULL,
                          double *exitDistance = NULL ) const;
    
    GF_API
    bool Intersect(const GfVec3d &origin,
                   const GfVec3d &axis,
                   const double  radius,
                   double        *enterDistance = NULL,
                   double        *exitDistance = NULL) const;
    
    GF_API
    bool Intersect(const GfVec3d &origin,
                   const GfVec3d &axis,
                   const double  radius,
                   const double  height,
                   double        *enterDistance = NULL,
                   double        *exitDistance = NULL) const;
 
  private:
    GF_API
    friend bool GfFindClosestPoints( const GfRay &, const GfLine &,
                                     GfVec3d *, GfVec3d *,
                                     double *, double * );
    GF_API
    friend bool GfFindClosestPoints( const GfRay &, const GfLineSeg &,
                                     GfVec3d *, GfVec3d *,
                                     double *, double * );
  
    bool _SolveQuadratic(const double a,
                         const double b,
                         const double c,
                         double       *enterDistance = NULL,
                         double       *exitDistance = NULL) const;
  
    GfVec3d             _startPoint;
    GfVec3d             _direction;
};
 
GF_API
bool GfFindClosestPoints( const GfRay &ray, const GfLine &line,
                          GfVec3d *rayPoint = nullptr,
                          GfVec3d *linePoint = nullptr,
                          double *rayDistance = nullptr,
                          double *lineDistance = nullptr );
 
GF_API
bool GfFindClosestPoints( const GfRay &ray, const GfLineSeg &seg,
                          GfVec3d *rayPoint = nullptr,
                          GfVec3d *segPoint = nullptr,
                          double *rayDistance = nullptr,
                          double *segDistance = nullptr );
 
GF_API std::ostream& operator<<(std::ostream&, const GfRay&);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_BASE_GF_RAY_H