File: [Development] / inventor / lib / database / include / Inventor / SbLinear.h (download)
Revision 1.3, Sun Oct 29 15:04:17 2000 UTC (17 years ago) by jlim
Branch: MAIN
CVS Tags: release-2_1_5-9, release-2_1_5-8, release-2_1_5-10, HEAD
Changes since 1.2: +77 -77
lines
Eliminated or reduced compiler errors and warnings, as tested with
egcs-2.91.66 (on Red Hat 6.0) and gcc 2.96 (on Red Hat 6.2).
|
/*
*
* Copyright (C) 2000 Silicon Graphics, Inc. All Rights Reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* Further, this software is distributed without any warranty that it is
* free of the rightful claim of any third person regarding infringement
* or the like. Any license provided herein, whether implied or
* otherwise, applies only to this software file. Patent licenses, if
* any, provided herein do not apply to combinations of this program with
* other software, or any other product whatsoever.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
* Mountain View, CA 94043, or:
*
* http://www.sgi.com
*
* For further information regarding this notice, see:
*
* http://oss.sgi.com/projects/GenInfo/NoticeExplan/
*
*/
// -*- C++ -*-
/*
* Copyright (C) 1990,91 Silicon Graphics, Inc.
*
_______________________________________________________________________
______________ S I L I C O N G R A P H I C S I N C . ____________
|
| $Revision: 1.3 $
|
| Description:
| This file contains definitions of various linear algebra classes,
| such as vectors, coordinates, etc..
|
| Classes:
| SbVec3f
| SbVec2f
| SbVec2s
| SbVec4f
| SbRotation
| SbMatrix
| SbViewVolume
|
| SbLine
| SbPlane
| SbSphere
|
| Author(s) : Paul S. Strauss, Nick Thompson,
| David Mott, Alain Dumesny
|
______________ S I L I C O N G R A P H I C S I N C . ____________
_______________________________________________________________________
*/
#ifndef _SB_LINEAR_
#define _SB_LINEAR_
#include <math.h>
#include <Inventor/SbBasic.h>
// -----------------------------------
//
// Types/classes defined in this file:
//
// -----------------------------------
// C-api: end
typedef float SbMat[4][4];
// C-api: begin
class SbVec3f;
class SbVec2f;
class SbVec2s;
class SbVec4f;
class SbRotation;
class SbMatrix;
class SbLine;
class SbPlane;
class SbCylinder;
class SbSphere;
// definition so we can use this in SbViewVolume
class SbBox3f;
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbVec3f
//
// 3D vector used to represent points or directions. Each component of
// the vector is a floating-point number.
//
// WARNING!!!!! Transcription of arrays of this class assume that the
// only data stored in this class are three consecutive values.
// Do not add any extra data members!!!
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbV3f
// C-api.h: struct SbVec3f {
// C-api.h: float vec[3];
// C-api.h: };
// C-api: end
class SbVec3f {
public:
// Default constructor
SbVec3f() { }
// Constructor given an array of 3 components
SbVec3f(const float v[3])
{ vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; }
// Constructor given 3 individual components
SbVec3f(float x, float y, float z)
{ vec[0] = x; vec[1] = y; vec[2] = z; }
// Constructor given 3 planes
SbVec3f(SbPlane &p0, SbPlane &p1, SbPlane &p2);
// C-api: begin
// Returns right-handed cross product of vector and another vector
SbVec3f cross(const SbVec3f &v) const;
// C-api: end
// Returns dot (inner) product of vector and another vector
float dot(const SbVec3f &v) const;
// C-api.h: #define SbV3fDot(_v0, _v1)
// C-api.h: ((_v0).vec[0] * (_v1).vec[0] + (_v0).vec[1] * (_v1).vec[1] +
// C-api.h: (_v0).vec[2] * (_v1).vec[2])
// Returns pointer to array of 3 components
const float *getValue() const { return vec; }
// C-api.h: #define SbV3fGetXYZ(_xyz, _src)
// C-api.h: (((_xyz)[0] = (_src).vec[0]), ((_xyz)[1] = (_src).vec[1]),
// C-api.h: ((_xyz)[2] = (_src).vec[2]))
// Returns 3 individual components
void getValue(float &x, float &y, float &z) const;
// C-api.h: #define SbV3fGetX_Y_Z(_x, _y, _z, _src)
// C-api.h: (((_x) = (_src).vec[0]), ((_y) = (_src).vec[1]), ((_z) = (_src).vec[2]))
// Returns geometric length of vector
float length() const;
// C-api.h: #define SbV3fLen(_v)
// C-api.h: (sqrtf(SbV3fDot((_v), (_v))))
// C-api: begin
// Changes vector to be unit length
// C-api: name=norm
float normalize();
// C-api: end
// Negates each component of vector in place
void negate();
// C-api.h: #define SbV3fNegate(_v)
// C-api.h: SbV3fMultBy(_v, -1.0)
// Sets value of vector from array of 3 components
SbVec3f & setValue(const float v[3])
{ vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; return *this; }
// C-api.h: #define SbV3fSetXYZ(_dest, _src)
// C-api.h: (((_dest).vec[0] = (_src)[0]), ((_dest).vec[1] = (_src)[1]),
// C-api.h: ((_dest).vec[2] = (_src)[2]))
// Sets value of vector from 3 individual components
SbVec3f & setValue(float x, float y, float z)
{ vec[0] = x; vec[1] = y; vec[2] = z; return *this; }
// C-api.h: #define SbV3fSetX_Y_Z(_dest, _x, _y, _z)
// C-api.h: (((_dest).vec[0] = (_x)), ((_dest).vec[1] = (_y)),
// C-api.h: ((_dest).vec[2] = (_z)))
// Sets value of vector to be convex combination of 3 other
// vectors, using barycentic coordinates
SbVec3f & setValue(const SbVec3f &barycentic,
const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2);
// Accesses indexed component of vector
float & operator [](int i) { return (vec[i]); }
const float & operator [](int i) const { return (vec[i]); }
// Component-wise scalar multiplication and division operators
SbVec3f & operator *=(float d);
// C-api.h: #define SbV3fMultBy(_v, _s)
// C-api.h: (((_v).vec[0] *= (_s)), ((_v).vec[1] *= (_s)), ((_v).vec[2] *= (_s)))
SbVec3f & operator /=(float d)
{ return *this *= (1.0 / d); }
// C-api.h: #define SbV3fDivBy(_v, _s)
// C-api.h: (((_v).vec[0] /= (_s)), ((_v).vec[1] /= (_s)), ((_v).vec[2] /= (_s)))
// Component-wise vector addition and subtraction operators
SbVec3f & operator +=(SbVec3f v);
SbVec3f & operator -=(SbVec3f v);
// Nondestructive unary negation - returns a new vector
SbVec3f operator -() const;
// Component-wise binary scalar multiplication and division operators
friend SbVec3f operator *(const SbVec3f &v, float d);
friend SbVec3f operator *(float d, const SbVec3f &v)
{ return v * d; }
friend SbVec3f operator /(const SbVec3f &v, float d)
{ return v * (1.0 / d); }
// Component-wise binary vector addition and subtraction operators
friend SbVec3f operator +(const SbVec3f &v1, const SbVec3f &v2);
// C-api.h: #define SbV3fAdd(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] + (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] + (_src2).vec[1]),
// C-api.h: ((_dest).vec[2] = (_src1).vec[2] + (_src2).vec[2]))
friend SbVec3f operator -(const SbVec3f &v1, const SbVec3f &v2);
// C-api.h: #define SbV3fSub(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] - (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] - (_src2).vec[1]),
// C-api.h: ((_dest).vec[2] = (_src1).vec[2] - (_src2).vec[2]))
// C-api: begin
// Equality comparison operator
friend int operator ==(const SbVec3f &v1, const SbVec3f &v2);
friend int operator !=(const SbVec3f &v1, const SbVec3f &v2)
{ return !(v1 == v2); }
// Equality comparison within given tolerance - the square of the
// length of the maximum distance between the two vectors
SbBool equals(const SbVec3f v, float tolerance) const;
// Returns principal axis that is closest (based on maximum dot
// product) to this vector
SbVec3f getClosestAxis() const;
protected:
float vec[3]; // Storage for vector components
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbVec2f
//
// 2D vector used to represet points or directions. Each component of
// the vector is a float.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbV2f
// C-api.h: struct SbVec2f {
// C-api.h: float vec[2];
// C-api.h: };
// C-api: end
class SbVec2f {
public:
// Default constructor
SbVec2f() { }
// Constructor given an array of 2 components
SbVec2f(const float v[2]) { setValue(v); }
// Constructor given 2 individual components
SbVec2f(float x, float y) { setValue(x, y); }
// Returns dot (inner) product of vector and another vector
float dot(const SbVec2f &v) const;
// C-api.h: #define SbV2fDot(_v0, _v1)
// C-api.h: ((_v0).vec[0] * (_v1).vec[0] + (_v0).vec[1] * (_v1).vec[1])
// Returns pointer to array of 2 components
const float *getValue() const { return vec; }
// C-api.h: #define SbV2fGetXY(_xy, _src)
// C-api.h: (((_xy)[0] = (_src).vec[0]), ((_xy)[1] = (_src).vec[1]))
// Returns 2 individual components
void getValue(float &x, float &y) const;
// C-api.h: #define SbV2fGetX_Y(_x, _y, _src)
// C-api.h: (((_x) = (_src).vec[0]), ((_y) = (_src).vec[1]))
// Returns geometric length of vector
float length() const;
// C-api.h: #define SbV2fLen(_v)
// C-api.h: (sqrtf(SbV2fDot((_v), (_v))))
// Negates each component of vector in place
void negate();
// C-api.h: #define SbV2fNegate(_v)
// C-api.h: SbV2fMultBy(_v, -1.0)
// C-api: begin
// Changes vector to be unit length
// C-api: name=norm
float normalize();
// C-api: end
// Sets value of vector from array of 2 components
SbVec2f & setValue(const float v[2]);
// C-api.h: #define SbV2fSetXY(_dest, _src)
// C-api.h: (((_dest).vec[0] = (_src)[0]), ((_dest).vec[1] = (_src)[1]))
// Sets value of vector from 2 individual components
SbVec2f & setValue(float x, float y);
// C-api.h: #define SbV2fSetX_Y(_dest, _x, _y)
// C-api.h: (((_dest).vec[0] = (_x)), ((_dest).vec[1] = (_y)))
// Accesses indexed component of vector
float & operator [](int i) { return (vec[i]); }
const float & operator [](int i) const { return (vec[i]); }
// Component-wise scalar multiplication and division operators
SbVec2f & operator *=(float d);
// C-api.h: #define SbV2fMultBy(_v, _s)
// C-api.h: (((_v).vec[0] *= (_s)), ((_v).vec[1] *= (_s)))
SbVec2f & operator /=(float d)
{ return *this *= (1.0 / d); }
// C-api.h: #define SbV2fDivBy(_v, _s)
// C-api.h: (((_v).vec[0] /= (_s)), ((_v).vec[1] /= (_s)))
// Component-wise vector addition and subtraction operators
SbVec2f & operator +=(const SbVec2f &u);
SbVec2f & operator -=(const SbVec2f &u);
// Nondestructive unary negation - returns a new vector
SbVec2f operator -() const;
// Component-wise binary scalar multiplication and division operators
friend SbVec2f operator *(const SbVec2f &v, float d);
friend SbVec2f operator *(float d, const SbVec2f &v)
{ return v * d; }
friend SbVec2f operator /(const SbVec2f &v, float d)
{ return v * (1.0 / d); }
// Component-wise binary vector addition and subtraction operators
friend SbVec2f operator +(const SbVec2f &v1, const SbVec2f &v2);
// C-api.h: #define SbV2fAdd(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] + (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] + (_src2).vec[1]))
friend SbVec2f operator -(const SbVec2f &v1, const SbVec2f &v2);
// C-api.h: #define SbV2fSub(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] - (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] - (_src2).vec[1]))
// C-api: begin
// Equality comparison operator
friend int operator ==(const SbVec2f &v1, const SbVec2f &v2);
friend int operator !=(const SbVec2f &v1, const SbVec2f &v2)
{ return !(v1 == v2); }
// Equality comparison within given tolerance - the square of the
// length of the maximum distance between the two vectors
SbBool equals(const SbVec2f v, float tolerance) const;
protected:
float vec[2]; // Storage for vector components
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbVec2s
//
// 2D vector used to represet points or directions. Each component of
// the vector is a (short) integer.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbV2s
// C-api.h: struct SbVec2s {
// C-api.h: short vec[2];
// C-api.h: };
// C-api: end
class SbVec2s {
public:
// Default constructor
SbVec2s() { }
// Constructor given an array of 2 components
SbVec2s(const short v[2]) { setValue(v); }
// Constructor given 2 individual components
SbVec2s(short x, short y) { setValue(x, y); }
// Returns dot (inner) product of vector and another vector
int32_t dot(const SbVec2s &v) const;
// C-api.h: #define SbV2sDot(_v0, _v1)
// C-api.h: ((_v0).vec[0] * (_v1).vec[0] + (_v0).vec[1] * (_v1).vec[1])
// Returns pointer to array of 2 components
const short *getValue() const { return vec; }
// C-api.h: #define SbV2sGetXY(_dest, _src)
// C-api.h: (((_dest)[0] = (_src).vec[0]), ((_dest)[1] = (_src).vec[1]))
// Returns 2 individual components
void getValue(short &x, short &y) const;
// C-api.h: #define SbV2sGetX_Y(_x, _y, _src)
// C-api.h: (((_x) = (_src).vec[0]), ((_y) = (_src).vec[1]))
// Negates each component of vector in place
void negate();
// C-api.h: #define SbV2sNegate(_v)
// C-api.h: SbV2sMultBy(_v, -1.0)
// Sets value of vector from array of 2 components
SbVec2s & setValue(const short v[2]);
// C-api.h: #define SbV2sSetXY(_dest, _src)
// C-api.h: (((_dest).vec[0] = (_src)[0]), ((_dest)[1] = (_src)[1]))
// Sets value of vector from 2 individual components
SbVec2s & setValue(short x, short y);
// C-api.h: #define SbV2sSetX_Y(_dest, _x, _y)
// C-api.h: (((_dest).vec[0] = (_x)), ((_dest).vec[1] = (_y)))
// Accesses indexed component of vector
short & operator [](int i) { return (vec[i]); }
const short & operator [](int i) const { return (vec[i]); }
// Component-wise scalar multiplication and division operators
SbVec2s & operator *=(int d);
SbVec2s & operator *=(double d);
// C-api.h: #define SbV2sMultBy(_v, _s)
// C-api.h: (((_v).vec[0] *= (_s)), ((_v).vec[1] *= (_s)))
SbVec2s & operator /=(int d);
SbVec2s & operator /=(double d)
{ return *this *= (1.0 / d); }
// C-api.h: #define SbV2sDivBy(_v, _s)
// C-api.h: (((_v).vec[0] /= (_s)), ((_v).vec[1] /= (_s)))
// Component-wise vector addition and subtraction operators
SbVec2s & operator +=(const SbVec2s &u);
SbVec2s & operator -=(const SbVec2s &u);
// Nondestructive unary negation - returns a new vector
SbVec2s operator -() const;
// Component-wise binary scalar multiplication and division operators
friend SbVec2s operator *(const SbVec2s &v, int d);
friend SbVec2s operator *(const SbVec2s &v, double d);
friend SbVec2s operator *(int d, const SbVec2s &v)
{ return v * d; }
friend SbVec2s operator *(double d, const SbVec2s &v)
{ return v * d; }
friend SbVec2s operator /(const SbVec2s &v, int d);
friend SbVec2s operator /(const SbVec2s &v, double d)
{ return v * (1.0 / d); }
// Component-wise binary vector addition and subtraction operators
friend SbVec2s operator +(const SbVec2s &v1, const SbVec2s &v2);
// C-api.h: #define SbV2sAdd(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] + (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] + (_src2).vec[1]))
friend SbVec2s operator -(const SbVec2s &v1, const SbVec2s &v2);
// C-api.h: #define SbV2sSub(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] - (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] - (_src2).vec[1]))
// C-api: begin
// Equality comparison operator
friend int operator ==(const SbVec2s &v1, const SbVec2s &v2);
friend int operator !=(const SbVec2s &v1, const SbVec2s &v2)
{ return !(v1 == v2); }
protected:
short vec[2]; // Storage for vector components
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbVec4f
//
// 4D vector used to represet rational points or directions. Each component of
// the vector is a float.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbV4f
// C-api.h: struct SbVec4f {
// C-api.h: float vec[4];
// C-api.h: };
// C-api: end
class SbVec4f {
public:
// Default constructor
SbVec4f() { }
// Constructor given an array of 4 components
SbVec4f(const float v[4]) { setValue(v); }
// Constructor given 4 individual components
SbVec4f(float x, float y, float z, float w) { setValue(x, y, z, w); }
// Returns dot (inner) product of vector and another vector
float dot(const SbVec4f &v) const;
// C-api.h: #define SbV4fDot(_v0, _v1)
// C-api.h: ((_v0).vec[0] * (_v1).vec[0] + (_v0).vec[1] * (_v1).vec[1] +
// C-api.h: (_v0).vec[2] * (_v1).vec[2] + (_v0).vec[3] * (_v1).vec[3])
// C-api: begin
// Returns the real portion of the vector by dividing by the fourth value
void getReal(SbVec3f &v) const;
// C-api: end
// Returns pointer to array of 4 components
const float *getValue() const { return vec; }
// C-api.h: #define SbV4fGetXYZW(_dest, _src)
// C-api.h: (((_dest)[0] = (_src).vec[0]), ((_dest)[1] = (_src).vec[1]),
// C-api.h: ((_dest)[2] = (_src).vec[2]), ((_dest)[3] = (_src).vec[3]))
// Returns 4 individual components
void getValue(float &x, float &y, float &z, float &w) const;
// C-api.h: #define SbV4fGetX_Y_Z_W(_x, _y, _z, _w, _src)
// C-api.h: (((_x) = (_src).vec[0]), ((_y) = (_src).vec[1]),
// C-api.h: ((_z) = (_src).vec[2]), ((_w) = (_src).vec[3]))
// Returns geometric length of vector
float length() const;
// C-api.h: #define SbV4fLen(_v)
// C-api.h: (sqrtf(SbV4fDot((_v), (_v))))
// Negates each component of vector in place
void negate();
// C-api.h: #define SbV4fNegate(_v)
// C-api.h: SbV4fMultBy(_v, -1.0)
// C-api: begin
// Changes vector to be unit length
// C-api: name=norm
float normalize();
// C-api: end
// Sets value of vector from array of 4 components
SbVec4f & setValue(const float v[4]);
// C-api.h: #define SbV4fSetXYZW(_dest, _src)
// C-api.h: (((_dest).vec[0] = (_src)[0]), ((_dest).vec[1] = (_src)[1]),
// C-api.h: ((_dest).vec[2] = (_src)[2]), ((_dest).vec[3] = (_src)[3]))
// Sets value of vector from 4 individual components
SbVec4f & setValue(float x, float y, float z, float w);
// C-api.h: #define SbV4fSetX_Y_Z_W(_dest, _x, _y, _z, _w)
// C-api.h: (((_dest).vec[0] = (_x)), ((_dest).vec[1] = (_y)),
// C-api.h: ((_dest).vec[2] = (_z)), ((_dest).vec[3] = (_w)))
// Accesses indexed component of vector
float & operator [](int i) { return (vec[i]); }
const float & operator [](int i) const { return (vec[i]); }
// Component-wise scalar multiplication and division operators
SbVec4f & operator *=(float d);
// C-api.h: #define SbV4fMultBy(_v, _s)
// C-api.h: (((_v).vec[0] *= (_s)), ((_v).vec[1] *= (_s)),
// C-api.h: ((_v).vec[2] *= (_s)), ((_v).vec[3] *= (_s)))
SbVec4f & operator /=(float d)
{ return *this *= (1.0 / d); }
// C-api.h: #define SbV4fDivBy(_v, _s)
// C-api.h: (((_v).vec[0] /= (_s)), ((_v).vec[1] /= (_s)),
// C-api.h: ((_v).vec[2] /= (_s)), ((_v).vec[3] /= (_s)))
// Component-wise vector addition and subtraction operators
SbVec4f & operator +=(const SbVec4f &u);
SbVec4f & operator -=(const SbVec4f &u);
// Nondestructive unary negation - returns a new vector
SbVec4f operator -() const;
// Component-wise binary scalar multiplication and division operators
friend SbVec4f operator *(const SbVec4f &v, float d);
friend SbVec4f operator *(float d, const SbVec4f &v)
{ return v * d; }
friend SbVec4f operator /(const SbVec4f &v, float d)
{ return v * (1.0 / d); }
// Component-wise binary vector addition and subtraction operators
friend SbVec4f operator +(const SbVec4f &v1, const SbVec4f &v2);
// C-api.h: #define SbV4fAdd(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] + (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] + (_src2).vec[1]),
// C-api.h: ((_dest).vec[2] = (_src1).vec[2] + (_src2).vec[2]))
// C-api.h: ((_dest).vec[3] = (_src1).vec[3] + (_src2).vec[3]))
friend SbVec4f operator -(const SbVec4f &v1, const SbVec4f &v2);
// C-api.h: #define SbV4fSub(_dest, _src1, _src2)
// C-api.h: (((_dest).vec[0] = (_src1).vec[0] - (_src2).vec[0]),
// C-api.h: ((_dest).vec[1] = (_src1).vec[1] - (_src2).vec[1]),
// C-api.h: ((_dest).vec[2] = (_src1).vec[2] - (_src2).vec[2]))
// C-api.h: ((_dest).vec[3] = (_src1).vec[3] - (_src2).vec[3]))
// C-api: begin
// Equality comparison operator
friend int operator ==(const SbVec4f &v1, const SbVec4f &v2);
friend int operator !=(const SbVec4f &v1, const SbVec4f &v2)
{ return !(v1 == v2); }
// Equality comparison within given tolerance - the square of the
// length of the maximum distance between the two vectors
SbBool equals(const SbVec4f v, float tolerance) const;
protected:
float vec[4]; // Storage for vector components
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbRotation
//
// Rotation specfication. It is stored internally as a quaternion,
// which has 4 floating-point components.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbRot
// C-api.h: struct SbRotation {
// C-api.h: float quat[4];
// C-api.h: };
// C-api: end
class SbRotation {
public:
// Default constructor
SbRotation()
{}
// Constructor given a quaternion as an array of 4 components
SbRotation(const float v[4])
{ setValue(v); }
// Constructor given 4 individual components of a quaternion
SbRotation(float q0, float q1, float q2, float q3)
{ setValue(q0, q1, q2, q3); }
// Constructor given a rotation matrix
SbRotation(const SbMatrix &m)
{ setValue(m); }
// Constructor given 3D rotation axis vector and angle in radians
SbRotation(const SbVec3f &axis, float radians)
{ setValue(axis, radians); }
// Constructor for rotation that rotates one direction vector to another
SbRotation(const SbVec3f &rotateFrom, const SbVec3f &rotateTo)
{ setValue(rotateFrom, rotateTo); }
// Returns pointer to array of 4 components defining quaternion
const float * getValue() const
{ return (quat); }
// C-api.h: #define SbRotGetQuat(_dest, _src)
// C-api.h: (((_dest)[0] = (_src).quat[0]), ((_dest)[1] = (_src).quat[1]),
// C-api.h: ((_dest)[2] = (_src).quat[2]), ((_dest)[3] = (_src).quat[3]))
// Returns 4 individual components of rotation quaternion
void getValue(float &q0, float &q1,
float &q2, float &q3) const;
// C-api.h: #define SbRotGetQ_U_A_T(_x, _y, _z, _w, _src)
// C-api.h: (((_x) = (_src).quat[0]), ((_y) = (_src).quat[1]),
// C-api.h: ((_z) = (_src).quat[2]), ((_w) = (_src).quat[3]))
// C-api: begin
// Returns corresponding 3D rotation axis vector and angle in radians
// C-api: name=getAxisAngle
void getValue(SbVec3f &axis, float &radians) const;
// Returns corresponding 4x4 rotation matrix
// C-api: name=getMx
void getValue(SbMatrix &matrix) const;
// Changes a rotation to be its inverse
SbRotation & invert();
// Returns the inverse of a rotation
SbRotation inverse() const
{ SbRotation q = *this; return q.invert(); }
// C-api: end
// Sets value of rotation from array of 4 components of a quaternion
SbRotation & setValue(const float q[4]);
// C-api.h: #define SbRotSetQuat(_dest, _src)
// C-api.h: (((_dest).quat[0] = (_src)[0]), ((_dest).quat[1] = (_src)[1]),
// C-api.h: ((_dest).quat[2] = (_src)[2]), ((_dest).quat[3] = (_src)[3]))
// Sets value of rotation from 4 individual components of a quaternion
SbRotation & setValue(float q0, float q1, float q2, float q3);
// C-api.h: #define SbRotSetQ_U_A_T(_dest, _x, _y, _z, _w)
// C-api.h: (((_dest).quat[0] = (_x)), ((_dest).quat[1] = (_y)),
// C-api.h: ((_dest).quat[2] = (_z)), ((_dest).quat[3] = (_w)))
// C-api: begin
// Sets value of rotation from a rotation matrix
// I don't know what will happen if you call this with something
// that isn't a rotation.
// C-api: name=setMx
SbRotation & setValue(const SbMatrix &m);
// Sets value of vector from 3D rotation axis vector and angle in radians
// C-api: name=setAxisAngle
SbRotation & setValue(const SbVec3f &axis, float radians);
// Sets rotation to rotate one direction vector to another
// C-api: name=setFromTo
SbRotation & setValue(const SbVec3f &rotateFrom,
const SbVec3f &rotateTo);
// C-api: end
// Multiplies by another rotation; results in product of rotations
SbRotation & operator *=(const SbRotation &q);
// C-api: begin
// Equality comparison operator
friend int operator ==(const SbRotation &q1, const SbRotation &q2);
friend int operator !=(const SbRotation &q1, const SbRotation &q2)
{ return !(q1 == q2); }
// Equality comparison within given tolerance - the square of the
// length of the maximum distance between the two quaternion vectors
SbBool equals(const SbRotation &r, float tolerance) const;
// Multiplication of two rotations; results in product of rotations
friend SbRotation operator *(const SbRotation &q1, const SbRotation &q2);
// Puts the given vector through this rotation
// (Multiplies the given vector by the matrix of this rotation),.
void multVec(const SbVec3f &src, SbVec3f &dst) const;
// Keep the axis the same. Multiply the angle of rotation by
// the amount 'scaleFactor'
void scaleAngle( float scaleFactor );
// Spherical linear interpolation: as t goes from 0 to 1, returned
// value goes from rot0 to rot1
static SbRotation slerp(const SbRotation &rot0,
const SbRotation &rot1, float t);
// Null rotation
// C-api: name=ident
static SbRotation identity()
{ return SbRotation(0.0, 0.0, 0.0, 1.0); }
private:
float quat[4]; // Storage for quaternion components
// Returns the norm (square of the 4D length) of a rotation's quaterion
float norm() const;
// Normalizes a rotation quaternion to unit 4D length
void normalize();
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbMatrix
//
// 4x4 matrix of floating-point elements.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbMx
// C-api.h: struct SbMatrix {
// C-api.h: float mx[4][4];
// C-api.h: };
// C-api: end
class SbMatrix {
public:
// Default constructor
SbMatrix() { }
// Constructor given all 16 elements in row-major order
SbMatrix(float a11, float a12, float a13, float a14,
float a21, float a22, float a23, float a24,
float a31, float a32, float a33, float a34,
float a41, float a42, float a43, float a44);
// Constructor from a 4x4 array of elements
SbMatrix(const SbMat &m);
// Sets value from 4x4 array of elements
void setValue(const SbMat &m);
public:
// C-api: begin
// Sets matrix to be identity
// C-api: name=makeIdent
void makeIdentity();
// Returns an identity matrix
// C-api: name=ident
static SbMatrix identity();
// Sets matrix to rotate by given rotation
// C-api: name=setRot
void setRotate(const SbRotation &q);
// Sets matrix to scale by given uniform factor
void setScale(float s);
// Sets matrix to scale by given vector
// C-api: name=scaleVec
void setScale(const SbVec3f &s);
// Sets matrix to translate by given vector
// C-api: name=setXlate
void setTranslate(const SbVec3f &t);
// Composes the matrix based on a translation, rotation, scale,
// orientation for scale, and center. The "center" is the
// center point for scaling and rotation. The "scaleOrientation"
// chooses the primary axes for the scale.
// C-api: name=setXform
void setTransform(
const SbVec3f &translation,
const SbRotation &rotation,
const SbVec3f &scaleFactor,
const SbRotation &scaleOrientation,
const SbVec3f ¢er);
// C-api: end
// Overloaded methods as a kludge because the compiler won't let
// us have SbVec3f(0,0,0) as a default value:
void setTransform(const SbVec3f &t, const SbRotation &r,
const SbVec3f &s)
{ setTransform(t, r, s,
SbRotation(0,0,0,1), SbVec3f(0,0,0)); }
void setTransform(const SbVec3f &t, const SbRotation &r,
const SbVec3f &s, const SbRotation &so)
{ setTransform(t, r, s, so, SbVec3f(0,0,0)); }
// C-api: begin
// Decomposes the matrix into a translation, rotation, scale,
// and scale orientation. Any projection information is discarded.
// The decomposition depends upon choice of center point for
// rotation and scaling, which is optional as the last parameter.
// Note that if the center is 0, decompose() is the same as
// factor() where "t" is translation, "u" is rotation, "s" is scaleFactor,
// and "r" is ScaleOrientattion.
// C-api: name=getXform
void getTransform(SbVec3f &translation,
SbRotation &rotation,
SbVec3f &scaleFactor,
SbRotation &scaleOrientation,
const SbVec3f ¢er) const;
// C-api: end
void getTransform(SbVec3f &t, SbRotation &r,
SbVec3f &s, SbRotation &so) const
{ getTransform(t, r, s, so, SbVec3f(0,0,0)); }
// The following methods return matrix values and other info:
// Returns 4x4 array of elements
void getValue(SbMat &m) const;
const SbMat & getValue() const { return matrix; }
// C-api: begin
// Returns determinant of 3x3 submatrix composed of given row and
// column indices (0-3 for each).
// C-api: name=det3Mx
float det3(int r1, int r2, int r3, int c1, int c2, int c3) const;
// Returns determinant of upper-left 3x3 submatrix
float det3() const { return det3(0, 1, 2, 0, 1, 2); }
// Returns determinant of entire matrix
float det4() const;
// Factors a matrix m into 5 pieces: m = r s r^ u t, where r^
// means transpose of r, and r and u are rotations, s is a scale,
// and t is a translation. Any projection information is returned
// in proj.
SbBool factor(SbMatrix &r, SbVec3f &s, SbMatrix &u,
SbVec3f &t, SbMatrix &proj) const;
// Returns inverse of matrix. Results are undefined for
// singular matrices. Uses LU decompostion
SbMatrix inverse() const;
// Perform in-place LU decomposition of matrix. indx is index of rows
// in matrix. d is the parity of row swaps. Returns FALSE if singular
// C-api: name=LUDecomp
SbBool LUDecomposition(int index[4], float &d);
// Perform back-substitution on LU-decomposed matrix. Index is
// permutation of rows from original matrix
// C-api: name=LUBackSub
void LUBackSubstitution(int index[4], float b[4]) const;
// Returns transpose of matrix
SbMatrix transpose() const;
// The following methods provide Mx/mx and mx/vec arithmetic:
// Multiplies matrix by given matrix on right or left
SbMatrix & multRight(const SbMatrix &m); // this = this * m
SbMatrix & multLeft(const SbMatrix &m); // this = m * this
// Multiplies matrix by given column vector, giving vector result
// C-api: name=multMxVec
void multMatrixVec(const SbVec3f &src, SbVec3f &dst) const;
// Multiplies given row vector by matrix, giving vector result
// C-api: name=multVecMx
void multVecMatrix(const SbVec3f &src, SbVec3f &dst) const;
// Multiplies given row vector by matrix, giving vector result
// src is assumed to be a direction vector, so translation part of
// matrix is ignored.
// C-api: name=multDirMx
void multDirMatrix(const SbVec3f &src, SbVec3f &dst) const;
// Multiplies the given line's origin by the matrix, and the
// line's direction by the rotation portion of the matrix
// C-api: name=multLineMx
void multLineMatrix(const SbLine &src, SbLine &dst) const;
// The following methods are miscellaneous Mx functions:
// Prints a formatted version of the matrix to the given file pointer
void print(FILE *fp) const;
// C-api: end
// Cast: returns pointer to storage of first element
operator float *() { return &matrix[0][0]; }
// Cast: returns reference to 4x4 array
operator SbMat &() { return matrix; }
// Make it look like a usual matrix (so you can do m[3][2])
float * operator [](int i) { return &matrix[i][0]; }
const float * operator [](int i) const { return &matrix[i][0]; }
// Sets value from 4x4 array of elements
SbMatrix & operator =(const SbMat &m);
// C-api: begin
SbMatrix & operator =(const SbMatrix &m);
// C-api: end
// This silly little inline method is needed because some
// compilers won't use the above method...
#ifdef __sgi
SbMatrix & operator =( SbMat &m) { return *this = (const SbMat &)m; }
#endif // __sgi
// Sets value from a rotation
SbMatrix & operator =(const SbRotation &q) { setRotate(q); return *this; }
// C-api: begin
// Performs right multiplication with another matrix
SbMatrix & operator *=(const SbMatrix &m) { return multRight(m); }
// Binary multiplication of matrices
friend SbMatrix operator *(const SbMatrix &m1, const SbMatrix &m2);
// Equality comparison operator
friend int operator ==(const SbMatrix &m1, const SbMatrix &m2);
friend int operator !=(const SbMatrix &m1, const SbMatrix &m2)
{ return !(m1 == m2); }
// Equality comparison within given tolerance, for each component
SbBool equals(const SbMatrix &m, float tolerance) const;
private:
SbMat matrix; // Storage for 4x4 matrix
// Diagonalizes 3x3 matrix
void jacobi3(float evalues[3], SbVec3f evectors[3], int &rots) const;
SbBool affine_inverse(const SbMatrix &in, SbMatrix &out) const;
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbViewVolume
//
// Defines a 3D view volume. For perspective projection, the view
// volume is a frustum. For orthographic (parallel) projection, the
// view volume is a rectangular prism.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbViewVol
class SbViewVolume {
public:
// Default constructor
SbViewVolume();
~SbViewVolume() {}
// Returns two matrices corresponding to the view volume. The
// first is a viewing matrix, which is guaranteed to be an affine
// transformation. The second is suitable for use as a projection
// matrix in GL.
// C-api: name=getMxs
void getMatrices(SbMatrix &affine, SbMatrix &proj) const;
// Like the method above, but returns the affine and projection parts
// together in one matrix (i.e. affine.multRight( proj ) ).
// C-api: name=getMx
SbMatrix getMatrix() const;
// Returns a matrix that transforms the view volume into camera
// space: it translates the view volume so the view point is at
// the origin, and rotates it so the view direction is along the
// negative z axis.
// C-api: name=getBoxMx
SbMatrix getCameraSpaceMatrix() const;
// Maps a 2d point (in 0 <= x,y <= 1) to a 3d line.
// C-api: name=projPtToLine
void projectPointToLine(const SbVec2f &pt,
SbLine &line) const;
// C-api: name=projPtToLinePts
void projectPointToLine(const SbVec2f &pt,
SbVec3f &line0, SbVec3f &line1) const;
// Maps the 3d point in world coordinates to a 2d point in
// normalized screen coordinates (0 <= x,y,z <= 1, 0 <= z <= 1).
// The z-screen coordinate represents the homogonized z coordinate
// which goes (non-linearly) from 0 at the near clipping plane to
// 1 at the far clipping plane.
// C-api: name=projToScreen
void projectToScreen(const SbVec3f &src,
SbVec3f &dst) const;
// Returns a plane parallel to the near (or far) plane of the view
// volume at a given distance from the projection point (eye)
// C-api: name=getPln
SbPlane getPlane(float distFromEye) const;
// Returns the point along the line of sight at the given distance
// from the projection point (eye)
// C-api: name=getSightPt
SbVec3f getSightPoint(float distFromEye) const;
// Returns the projection of a given point in normalized screen
// coords (see projectToScreen()) onto the plane parallel to the
// near plane that is at distFromEye units from the eye
// C-api: name=getPlnPt
SbVec3f getPlanePoint(float distFromEye,
const SbVec2f &normPoint) const;
// Returns a rotation that would align a viewed object so that
// its positive x-axis (of its object space) is to the right in
// the view and it's positive y-axis is up. If rightAngleOnly is
// TRUE, it will come as close as it can to this goal by using
// only 90 degree rotations.
// C-api: name=getAlignRot
SbRotation getAlignRotation(SbBool rightAngleOnly = FALSE) const;
// Returns a scale factor that would scale a unit sphere centered
// at worldCenter so that it would appear to have the given radius
// in normalized screen coordinates when projected onto the near plane
float getWorldToScreenScale(const SbVec3f &worldCenter,
float normRadius) const;
// Projects the given 3D bounding box onto the near plane and
// returns the size (in normalized screen coords) of the
// rectangular region that encloses it
// C-api: name=projBox
SbVec2f projectBox(const SbBox3f &box) const;
// Given a view volume, this narrows the view to the given sub-rectangle
// of the near plane. The coordinates of the rectangle are between
// 0 and 1, where (0,0) is the lower-left corner of the near plane
// and (1,1) is the upper-right corner.
// C-api: name=narrow2d
SbViewVolume narrow(float left, float bottom,
float right, float top) const;
// Narrow a view volume by the given box. The box must lie inside
// the unit cube, and the view will be shrunk according to the
// size of the box.
// C-api: name=narrow3d
SbViewVolume narrow(const SbBox3f &box) const;
// Sets up an orthographic view volume with the given sides.
// The parameters are the same as for the GL ortho() routine.
void ortho(float left, float right,
float bottom, float top,
float near, float far);
// Sets up a perspective view volume with the given field of view
// and aspect ratio. The parameters are the same as for the GL
// perspective() routine, except that the field of view angle is
// specified in radians.
// C-api: name=persp
void perspective(float fovy, float aspect,
float near, float far);
// Rotate the camera view direction. Note that this accomplishes
// the reverse of doing a GL rotate() command after defining a
// camera, which rotates the scene viewed by the camera.
// C-api: name=rotCam
void rotateCamera(const SbRotation &q);
// Translate the camera viewpoint. Note that this accomplishes
// the reverse of doing a GL translate() command after defining a
// camera, which translates the scene viewed by the camera.
// C-api: name=xlateCam
void translateCamera(const SbVec3f &v);
// Returns the positive z axis in eye space. In this coordinate
// system, the z value of the near plane should be GREATER than the
// z value of the far plane.
// C-api: name=zVec
SbVec3f zVector() const;
// Returns a narrowed view volume which contains as tightly as
// possible the given interval on the z axis (in eye space). The
// returned view volume will never be larger than the current volume,
// however. Near and far are given in terms of zVector(): this
// means that near > far must hold.
SbViewVolume zNarrow(float near, float far) const;
// Scales width and height of view volume by given factor
void scale(float factor);
// Scales view volume to be the given ratio of its current width
// or height, leaving the resulting view volume centered about the
// same point (in the near plane) as the current one.
void scaleWidth(float ratio);
void scaleHeight(float ratio);
// Return projection information
enum ProjectionType {
ORTHOGRAPHIC,
PERSPECTIVE
};
// C-api: name=getProjType
ProjectionType getProjectionType() const { return type; }
// C-api: name=getProjPt
const SbVec3f & getProjectionPoint() const { return projPoint; }
// C-api: name=getProjDir
const SbVec3f & getProjectionDirection() const { return projDir; }
// Returns distance from projection point to near plane
float getNearDist() const { return nearDist; }
// return bounds of viewing frustum
float getWidth() const { return (lrfO-llfO).length(); }
float getHeight() const { return (ulfO-llfO).length(); }
float getDepth() const { return nearToFar; }
SoINTERNAL public:
ProjectionType type;
// Note that there is redundant info in this data structure and its
// elements should not be changed by hand.
SbVec3f projPoint; // must be (0,0,0) for ortho
SbVec3f projDir;
float nearDist; // distance to near plane
float nearToFar; // distance between z clips
SbVec3f llf;
SbVec3f lrf;
SbVec3f ulf;
// Transforms the view volume by the given matrix. NOTE: if the
// matrix performs a scale and a rotation, angles between the
// transformed projection direction and the sides of the view
// volume may not be preserved.
void transform(const SbMatrix &matrix);
// Returns TRUE if view volume contains point
SbBool intersect(const SbVec3f &point) const;
// Returns TRUE if line segment between 2 points may intersect
// volume. Returns closest point on line to center ray of volume
// if intersection is found.
SbBool intersect(const SbVec3f &p0, const SbVec3f &p1,
SbVec3f &closestPoint) const;
// Returns TRUE if bounding box may intersect volume
SbBool intersect(const SbBox3f &box) const;
// Returns TRUE if the bounding box defined by min,max is totally
// outside plane p.
SbBool outsideTest(const SbPlane &p,
const SbVec3f &min, const SbVec3f &max) const;
private:
// Points on the near clipping plane. Add in the projPoint to
// figure out where they are in world space:
SbVec3f llfO; // x = -w, y = -w, z = -w
SbVec3f lrfO; // x = w, y = -w, z = -w
SbVec3f ulfO; // x = -w, y = w, z = -w
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbLine
//
// Represents a directed line in 3D space.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: public=pos, dir
class SbLine {
public:
// C-api: end
SbLine() {}
// Construct a line from two points lying on the line. If you
// want to construct a line from a position and a direction, use
// SbLine(p, p + d).
// Line is directed from p0 to p1.
SbLine(const SbVec3f &p0, const SbVec3f &p1);
// Set that value!
void setValue(const SbVec3f &p0, const SbVec3f &p1);
// C-api: begin
// Find closest points between the two lines. Return FALSE if they are
// parallel, otherwise return TRUE.
// C-api: name=getClosestPts
SbBool getClosestPoints(const SbLine &line2,
SbVec3f &ptOnThis,
SbVec3f &ptOnLine2 ) const;
// Returns the closest point on the line to the given point.
// C-api: name=getClosestPt
SbVec3f getClosestPoint(const SbVec3f &point) const;
// C-api: end
// Accessors
const SbVec3f & getPosition() const { return pos; }
const SbVec3f & getDirection() const { return dir; }
// C-api: begin
SoINTERNAL public:
// Intersect the line with a box, point, line, and triangle.
SbBool intersect( const SbBox3f &box,
SbVec3f &enter, SbVec3f &exit ) const;
SbBool intersect( float angle, const SbBox3f &box ) const;
SbBool intersect( float angle, const SbVec3f &point ) const;
SbBool intersect( float angle, const SbVec3f &v0,
const SbVec3f &v1, SbVec3f &pt ) const;
SbBool intersect( const SbVec3f &v0,
const SbVec3f &v1,
const SbVec3f &v2,
SbVec3f &pt, SbVec3f &barycentric,
SbBool &front ) const;
private:
// Parametric description:
// l(t) = pos + t * dir
SbVec3f pos;
SbVec3f dir;
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbPlane
//
// Represents an oriented plane in 3D space. The plane is defined by
// a plane normal and a distance from the origin along that normal.
// SbPlanes may be used to represent either planes or half-spaces. In
// the latter case (as for the isInHalfSpace() method), the
// half-space is defined to be all points on the plane or on the side
// of the plane in the direction of the plane normal.
//
// The 4 coefficients of the plane equation of an SbPlane can be
// obtained easily as the 3 coordinates of the plane normal and the
// distance, in that order.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbPln
// C-api: public=normalVec, distance
class SbPlane {
public:
// C-api: end
SbPlane() {}
// Construct a plane given 3 points.
// Orientation is computed by taking (p1 - p0) x (p2 - p0) and
// pointing the normal in that direction.
SbPlane(const SbVec3f &p0, const SbVec3f &p1, const SbVec3f &p2);
// Construct a plane given normal and distance from origin along normal.
// Orientation is given by the normal vector n.
SbPlane(const SbVec3f &n, float d);
// Construct a plane given normal and a point to pass through
// Orientation is given by the normal vector n.
SbPlane(const SbVec3f &n, const SbVec3f &p);
// C-api: begin
// Offset a plane by a given distance.
void offset(float d);
// Intersect line and plane, returning TRUE if there is an intersection
// FALSE if line is parallel to plane
SbBool intersect(const SbLine &l,
SbVec3f &intersection) const;
// Transforms the plane by the given matrix
void transform(const SbMatrix &matrix);
// Returns TRUE if the given point is within the half-space
// defined by the plane
SbBool isInHalfSpace(const SbVec3f &point) const;
// C-api: end
// Accessors
const SbVec3f & getNormal() const { return normalVec; }
float getDistanceFromOrigin() const { return distance; }
// C-api: begin
// Equality/inequality comparison operators
friend int operator ==(const SbPlane &p1, const SbPlane &p2);
friend int operator !=(const SbPlane &p1, const SbPlane &p2)
{ return !(p1 == p2); }
private:
// Plane is all p such that normalVec . p - distance = 0
// Normal to the plane
SbVec3f normalVec;
// Distance from origin to plane: distance * normalVec is on the plane
float distance;
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbCylinder
//
// Represents a cylinder in 3D space.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbCyl
// C-api: public=axis, radius
class SbCylinder {
public:
// C-api: end
// Constructor
SbCylinder();
// Construct a cylinder given its axis and radius
SbCylinder(const SbLine &a, float r);
// Change the axis and radius
void setValue(const SbLine &a, float r);
// Set just the axis or radius
void setAxis(const SbLine &a);
void setRadius(float r);
// Return the axis and radius
const SbLine & getAxis() const { return axis; }
float getRadius() const { return radius; }
// C-api: begin
// Intersect line and cylinder, returning TRUE if there is an intersection
SbBool intersect(const SbLine &l, SbVec3f &intersection) const;
// C-api: name=intersect2
SbBool intersect(const SbLine &l,
SbVec3f &enter, SbVec3f &exit) const;
private:
SbLine axis;
float radius;
static SbBool unitCylinderIntersect(const SbLine &l,
SbVec3f &in, SbVec3f &out);
};
//////////////////////////////////////////////////////////////////////////////
//
// Class: SbSphere
//
// Represents a sphere in 3D space.
//
//////////////////////////////////////////////////////////////////////////////
// C-api: prefix=SbSph
// C-api: public=center, radius
class SbSphere {
public:
// C-api: end
// Boring default constructor
SbSphere() {}
// Construct a sphere given center and radius
SbSphere(const SbVec3f &c, float r);
// Change the center and radius
void setValue(const SbVec3f &c, float r);
// Set just the center or radius
void setCenter(const SbVec3f &c);
void setRadius(float r);
// Return the center and radius
const SbVec3f & getCenter() const { return center; }
float getRadius() const { return radius; }
// C-api: begin
// Return a sphere containing a given box
void circumscribe(const SbBox3f &box);
// Intersect line and sphere, returning TRUE if there is an intersection
SbBool intersect(const SbLine &l, SbVec3f &intersection) const;
// C-api: name=intersect2
SbBool intersect(const SbLine &l, SbVec3f &enter, SbVec3f &exit) const;
private:
SbVec3f center;
float radius;
};
#endif /* _SB_LINEAR_ */
![[BACK]](/icons/back.gif){kind=icon}
Return to SbLinear.h CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / inventor / lib / database / include / Inventor