FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

From Sébastien Kuntz, spelling and typo fixes

Browse Source
This commit is contained in:
Robert Osfield 2004-08-31 13:19:30 +00:00
parent 08017daf37
commit 3b90a0e8a6
8 changed files with 363 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
include/osg/LightSource
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -20,14 +20,16 @@
namespace osg { namespace osg {
/** Leaf Node for defining a light in the scene.*/ /** Leaf Node for defining a light in the scene. */
class SG_EXPORT LightSource : public Group class SG_EXPORT LightSource : public Group
{ {
public: public:
LightSource(); LightSource();
LightSource(const LightSource& ls, const CopyOp& copyop=CopyOp::SHALLOW_COPY): /** Copy constructor using CopyOp to manage deep vs shallow copy. */
LightSource(const LightSource& ls,
const CopyOp& copyop=CopyOp::SHALLOW_COPY):
Group(ls,copyop), Group(ls,copyop),
_value(ls._value), _value(ls._value),
_light(dynamic_cast<osg::Light*>(copyop(ls._light.get()))) {} _light(dynamic_cast<osg::Light*>(copyop(ls._light.get()))) {}
@ -46,28 +48,29 @@ class SG_EXPORT LightSource : public Group
* Note: setting the ReferenceFrame to be RELATIVE_TO_ABSOLUTE will * Note: setting the ReferenceFrame to be RELATIVE_TO_ABSOLUTE will
* also set the CullingActive flag on the light source, and hence all * also set the CullingActive flag on the light source, and hence all
* of its parents, to false, thereby disabling culling of it and * of its parents, to false, thereby disabling culling of it and
* all its parents. This is neccessary to prevent inappropriate * all its parents. This is necessary to prevent inappropriate
* culling, but may impact cull times if the absolute light source is * culling, but may impact cull times if the absolute light source is
* deep in the scene graph. It is therefore recommend to only use * deep in the scene graph. It is therefore recommended to only use
* absolute light source at the top of the scene. */ * absolute light source at the top of the scene.
*/
void setReferenceFrame(ReferenceFrame rf); void setReferenceFrame(ReferenceFrame rf);
ReferenceFrame getReferenceFrame() const { return _referenceFrame; } ReferenceFrame getReferenceFrame() const { return _referenceFrame; }
/** Set the attached light.*/ /** Set the attached light. */
void setLight(Light* light); void setLight(Light* light);
/** Get the attached light.*/ /** Get the attached light. */
inline Light* getLight() { return _light.get(); } inline Light* getLight() { return _light.get(); }
/** Get the const attached light.*/ /** Get the const attached light. */
inline const Light* getLight() const { return _light.get(); } inline const Light* getLight() const { return _light.get(); }
/** Set the GLModes on StateSet associated with the LightSource.*/ /** Set the GLModes on StateSet associated with the LightSource. */
void setStateSetModes(StateSet&,StateAttribute::GLModeValue) const; void setStateSetModes(StateSet&,StateAttribute::GLModeValue) const;
/** Set up the local StateSet */ /** Set up the local StateSet. */
void setLocalStateSetModes(StateAttribute::GLModeValue=StateAttribute::ON); void setLocalStateSetModes(StateAttribute::GLModeValue value = StateAttribute::ON);
protected: protected:

20
include/osg/LineSegment
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -20,7 +20,7 @@
namespace osg { namespace osg {
/** LineSegment class for representing a line segment.*/ /** LineSegment class for representing a line segment. */
class SG_EXPORT LineSegment : public Referenced class SG_EXPORT LineSegment : public Referenced
{ {
public: public:
@ -41,19 +41,25 @@ class SG_EXPORT LineSegment : public Referenced
inline bool valid() const { return _s.valid() && _e.valid() && _s!=_e; } inline bool valid() const { return _s.valid() && _e.valid() && _s!=_e; }
/** return true if segment intersects BoundingBox.*/ /** return true if segment intersects BoundingBox. */
bool intersect(const BoundingBox& bb) const; bool intersect(const BoundingBox& bb) const;
/** return true if segment intersects BoundingBox and return the intersection ratio's.*/ /** return true if segment intersects BoundingBox
* and return the intersection ratios.
*/
bool intersect(const BoundingBox& bb,float& r1,float& r2) const; bool intersect(const BoundingBox& bb,float& r1,float& r2) const;
/** return true if segment intersects BoundingSphere.*/ /** return true if segment intersects BoundingSphere. */
bool intersect(const BoundingSphere& bs) const; bool intersect(const BoundingSphere& bs) const;
/** return true if segment intersects BoundingSphere and return the intersection ratio's.*/ /** return true if segment intersects BoundingSphere and return the
* intersection ratio.
*/
bool intersect(const BoundingSphere& bs,float& r1,float& r2) const; bool intersect(const BoundingSphere& bs,float& r1,float& r2) const;
/** return true if segment intersects triangle and set ratio long segment. */ /** return true if segment intersects triangle
* and set ratio long segment.
*/
bool intersect(const Vec3& v1,const Vec3& v2,const Vec3& v3,float& r); bool intersect(const Vec3& v1,const Vec3& v2,const Vec3& v3,float& r);
/** post multiply a segment by matrix.*/ /** post multiply a segment by matrix.*/

12
include/osg/LineStipple
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -32,18 +32,18 @@ class SG_EXPORT LineStipple : public StateAttribute
META_StateAttribute(osg, LineStipple, LINESTIPPLE); META_StateAttribute(osg, LineStipple, LINESTIPPLE);
/** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/ /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */
virtual int compare(const StateAttribute& sa) const virtual int compare(const StateAttribute& sa) const
{ {
// check the types are equal and then create the rhs variable // check if the types are equal and then create the rhs variable.
// used by the COMPARE_StateAttribute_Paramter macro's below. // used by the COMPARE_StateAttribute_Parameter macros below.
COMPARE_StateAttribute_Types(LineStipple,sa) COMPARE_StateAttribute_Types(LineStipple,sa)
// compare each paramter in turn against the rhs. // compare each parameter in turn against the rhs.
COMPARE_StateAttribute_Parameter(_factor) COMPARE_StateAttribute_Parameter(_factor)
COMPARE_StateAttribute_Parameter(_pattern) COMPARE_StateAttribute_Parameter(_pattern)
return 0; // passed all the above comparison macro's, must be equal. return 0; // passed all the above comparison macros, must be equal.
} }
virtual bool getModeUsage(ModeUsage& usage) const virtual bool getModeUsage(ModeUsage& usage) const

22
include/osg/LineWidth
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -11,38 +11,38 @@
* OpenSceneGraph Public License for more details. * OpenSceneGraph Public License for more details.
*/ */
#ifndef OSG_LineWidth #ifndef OSG_LINEWIDTH
#define OSG_LineWidth 1 #define OSG_LINEWIDTH 1
#include <osg/StateAttribute> #include <osg/StateAttribute>
namespace osg { namespace osg {
/** LineWidth - encapsulates the OpenGL glLineWidth for setting the width of lines in pixels.*/ /** LineWidth - encapsulates the OpenGL glLineWidth for setting the width of lines in pixels. */
class SG_EXPORT LineWidth : public StateAttribute class SG_EXPORT LineWidth : public StateAttribute
{ {
public : public :
LineWidth(float width=1.0f); LineWidth(float width=1.0f);
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/ /** Copy constructor using CopyOp to manage deep vs shallow copy. */
LineWidth(const LineWidth& lw,const CopyOp& copyop=CopyOp::SHALLOW_COPY): LineWidth(const LineWidth& lw,const CopyOp& copyop=CopyOp::SHALLOW_COPY) :
StateAttribute(lw,copyop), StateAttribute(lw,copyop),
_width(lw._width) {} _width(lw._width) {}
META_StateAttribute(osg, LineWidth, LINEWIDTH); META_StateAttribute(osg, LineWidth, LINEWIDTH);
/** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/ /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */
virtual int compare(const StateAttribute& sa) const virtual int compare(const StateAttribute& sa) const
{ {
// check the types are equal and then create the rhs variable // check if the types are equal and then create the rhs variable
// used by the COMPARE_StateAttribute_Paramter macro's below. // used by the COMPARE_StateAttribute_Parameter macros below.
COMPARE_StateAttribute_Types(LineWidth,sa) COMPARE_StateAttribute_Types(LineWidth,sa)
// compare each paramter in turn against the rhs. // compare each parameter in turn against the rhs.
COMPARE_StateAttribute_Parameter(_width) COMPARE_StateAttribute_Parameter(_width)
return 0; // passed all the above comparison macro's, must be equal. return 0; // passed all the above comparison macros, must be equal.
} }
void setWidth(float width); void setWidth(float width);

59
include/osg/Material
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -21,13 +21,11 @@ namespace osg {
/** Material - encapsulates OpenGL glMaterial state.*/ /** Material - encapsulates OpenGL glMaterial state.*/
class SG_EXPORT Material : public StateAttribute class SG_EXPORT Material : public StateAttribute
{ {
public : public :
Material(); Material();
/** Copy constructor using CopyOp to manage deep vs shallow copy.*/ /** Copy constructor using CopyOp to manage deep vs shallow copy. */
Material(const Material& mat,const CopyOp& copyop=CopyOp::SHALLOW_COPY): Material(const Material& mat,const CopyOp& copyop=CopyOp::SHALLOW_COPY):
StateAttribute(mat,copyop), StateAttribute(mat,copyop),
_colorMode(mat._colorMode), _colorMode(mat._colorMode),
@ -49,11 +47,11 @@ class SG_EXPORT Material : public StateAttribute
META_StateAttribute(osg, Material, MATERIAL); META_StateAttribute(osg, Material, MATERIAL);
/** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.*/ /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */
virtual int compare(const StateAttribute& sa) const virtual int compare(const StateAttribute& sa) const
{ {
// check the types are equal and then create the rhs variable // check the types are equal and then create the rhs variable
// used by the COMPARE_StateAttribute_Paramter macro's below. // used by the COMPARE_StateAttribute_Parameter macros below.
COMPARE_StateAttribute_Types(Material,sa) COMPARE_StateAttribute_Types(Material,sa)
// compare each parameter in turn against the rhs. // compare each parameter in turn against the rhs.
@ -74,7 +72,7 @@ class SG_EXPORT Material : public StateAttribute
COMPARE_StateAttribute_Parameter(_shininessFront) COMPARE_StateAttribute_Parameter(_shininessFront)
COMPARE_StateAttribute_Parameter(_shininessBack) COMPARE_StateAttribute_Parameter(_shininessBack)
return 0; // passed all the above comparison macro's, must be equal. return 0; // passed all the above comparison macros, must be equal.
} }
Material& operator = (const Material& rhs); Material& operator = (const Material& rhs);
@ -114,34 +112,53 @@ class SG_EXPORT Material : public StateAttribute
inline bool getDiffuseFrontAndBack() const { return _diffuseFrontAndBack; } inline bool getDiffuseFrontAndBack() const { return _diffuseFrontAndBack; }
/** Set specular value of specified face(s) of the material, /** Set specular value of specified face(s) of the material,
* valid specular[0..3] range is 0.0 to 1.0.*/ * valid specular[0..3] range is 0.0 to 1.0.
*/
void setSpecular( Face face, const Vec4& specular ); void setSpecular( Face face, const Vec4& specular );
/** Get the specular value for specified face.*/
/** Get the specular value for specified face. */
const Vec4& getSpecular(Face face) const; const Vec4& getSpecular(Face face) const;
/** Get the whether specular values are equal for front and back faces.*/
/** Return whether specular values are equal for front and back faces
* or not.
*/
inline bool getSpecularFrontAndBack() const { return _specularFrontAndBack; } inline bool getSpecularFrontAndBack() const { return _specularFrontAndBack; }
/** Set emission value of specified face(s) of the material, /** Set emission value of specified face(s) of the material,
* valid emmison[0..3] range is 0.0 to 1.0.*/ * valid emission[0..3] range is 0.0 to 1.0.
*/
void setEmission( Face face, const Vec4& emission ); void setEmission( Face face, const Vec4& emission );
/** Get the emmsion value for specified face.*/
/** Get the emission value for specified face. */
const Vec4& getEmission(Face face) const; const Vec4& getEmission(Face face) const;
/** Get the whether emission values are equal for front and back faces.*/
/** Return whether emission values are equal for front and back faces
* or not.
*/
inline bool getEmissionFrontAndBack() const { return _emissionFrontAndBack; } inline bool getEmissionFrontAndBack() const { return _emissionFrontAndBack; }
/** Set shininess of specified face(s) of the material, valid shininess range is 0.0 to 128.0.*/ /** Set shininess of specified face(s) of the material.
* valid shininess range is 0.0 to 128.0.
*/
void setShininess(Face face, float shininess ); void setShininess(Face face, float shininess );
/** Get the shininess value for specified face.*/
/** Get the shininess value for specified face. */
float getShininess(Face face) const; float getShininess(Face face) const;
/** Get the whether shininess values are equal for front and back faces.*/
/** Return whether shininess values are equal for front and back faces
* or not.
*/
inline bool getShininessFrontAndBack() const { return _shininessFrontAndBack; } inline bool getShininessFrontAndBack() const { return _shininessFrontAndBack; }
/** Set the alpha value of ambient,diffuse,specular and emission colors, /** Set the alpha value of ambient, diffuse, specular and emission
* of specified face, to 1-transparency. Valid transparency range is 0.0 to 1.0.*/ * colors of specified face, to 1-transparency.
* Valid transparency range is 0.0 to 1.0.
*/
void setTransparency(Face face,float trans); void setTransparency(Face face,float trans);
/** Set the alpha value of ambient,diffuse,specular and emission colors. /** Set the alpha value of ambient, diffuse, specular and emission
* Valid transparency range is 0.0 to 1.0.*/ * colors. Valid transparency range is 0.0 to 1.0.
*/
void setAlpha(Face face,float alpha); void setAlpha(Face face,float alpha);
protected : protected :
@ -166,7 +183,7 @@ class SG_EXPORT Material : public StateAttribute
Vec4 _emissionFront; // r, g, b, w Vec4 _emissionFront; // r, g, b, w
Vec4 _emissionBack; // r, g, b, w Vec4 _emissionBack; // r, g, b, w
bool _shininessFrontAndBack; bool _shininessFrontAndBack;
float _shininessFront; // values 0 - 128.0 float _shininessFront; // values 0 - 128.0
float _shininessBack; // values 0 - 128.0 float _shininessBack; // values 0 - 128.0

48
include/osg/Math
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -98,7 +98,7 @@
namespace osg { namespace osg {
// define the stand trig values // define the standard trig values
#ifdef PI #ifdef PI
#undef PI #undef PI
#undef PI_2 #undef PI_2
@ -108,29 +108,44 @@ const double PI = 3.14159265358979323846;
const double PI_2 = 1.57079632679489661923; const double PI_2 = 1.57079632679489661923;
const double PI_4 = 0.78539816339744830962; const double PI_4 = 0.78539816339744830962;
/** return the minimum of two values, equivilant to std::min. /** return the minimum of two values, equivalent to std::min.
* std::min not used because of STL implementation under IRIX contains no std::min.*/ * std::min not used because of STL implementation under IRIX not
* containing std::min.
*/
template<typename T> template<typename T>
inline T absolute(T v) { return v<(T)0?-v:v; } inline T absolute(T v) { return v<(T)0?-v:v; }
/** return true if float lhs and rhs are equivalent, meaning that the difference between then is less than an epsilon value which default to 1e-6.*/ /** return true if float lhs and rhs are equivalent,
inline float equivalent(float lhs,float rhs,float epsilon=1e-6) { float delta = rhs-lhs; return delta<0.0f?delta>=-epsilon:delta<=epsilon; } * meaning that the difference between them is less than an epsilon value
* which defaults to 1e-6.
*/
inline float equivalent(float lhs,float rhs,float epsilon=1e-6)
{ float delta = rhs-lhs; return delta<0.0f?delta>=-epsilon:delta<=epsilon; }
/** return true if double lhs and rhs are equivalent, meaning that the difference between then is less than an epsilon value which default to 1e-6.*/ /** return true if double lhs and rhs are equivalent,
inline double equivalent(double lhs,double rhs,double epsilon=1e-6) { double delta = rhs-lhs; return delta<0.0?delta>=-epsilon:delta<=epsilon; } * meaning that the difference between them is less than an epsilon value
* which defaults to 1e-6.
*/
inline double equivalent(double lhs,double rhs,double epsilon=1e-6)
{ double delta = rhs-lhs; return delta<0.0?delta>=-epsilon:delta<=epsilon; }
/** return the minimum of two values, equivilant to std::min. /** return the minimum of two values, equivilent to std::min.
* std::min not used because of STL implementation under IRIX contains no std::min.*/ * std::min not used because of STL implementation under IRIX not containing
* std::min.
*/
template<typename T> template<typename T>
inline T minimum(T lhs,T rhs) { return lhs<rhs?lhs:rhs; } inline T minimum(T lhs,T rhs) { return lhs<rhs?lhs:rhs; }
/** return the maximum of two values, equivilant to std::max. /** return the maximum of two values, equivilent to std::max.
* std::max not used because of STL implementation under IRIX contains no std::max.*/ * std::max not used because of STL implementation under IRIX not containing
* std::max.
*/
template<typename T> template<typename T>
inline T maximum(T lhs,T rhs) { return lhs>rhs?lhs:rhs; } inline T maximum(T lhs,T rhs) { return lhs>rhs?lhs:rhs; }
template<typename T> template<typename T>
inline T clampTo(T v,T minimum,T maximum) { return v<minimum?minimum:v>maximum?maximum:v; } inline T clampTo(T v,T minimum,T maximum)
{ return v<minimum?minimum:v>maximum?maximum:v; }
template<typename T> template<typename T>
inline T clampAbove(T v,T minimum) { return v<minimum?minimum:v; } inline T clampAbove(T v,T minimum) { return v<minimum?minimum:v; }
@ -139,7 +154,8 @@ template<typename T>
inline T clampBelow(T v,T maximum) { return v>maximum?maximum:v; } inline T clampBelow(T v,T maximum) { return v>maximum?maximum:v; }
template<typename T> template<typename T>
inline T clampBetween(T v,T minimum, T maximum) { return clampBelow(clampAbove(v,minimum),maximum); } inline T clampBetween(T v,T minimum, T maximum)
{ return clampBelow(clampAbove(v,minimum),maximum); }
template<typename T> template<typename T>
inline T sign(T v) { return v<(T)0?(T)-1:(T)1; } inline T sign(T v) { return v<(T)0?(T)-1:(T)1; }
@ -176,14 +192,14 @@ inline double RadiansToDegrees(double angle) { return angle*180.0/PI; }
#endif #endif
/** compute the volume of tetrahedron */ /** compute the volume of a tetrahedron. */
template<typename T> template<typename T>
inline float computeVolume(const T& a,const T& b,const T& c,const T& d) inline float computeVolume(const T& a,const T& b,const T& c,const T& d)
{ {
return fabsf(((b-c)^(a-b))*(d-b)); return fabsf(((b-c)^(a-b))*(d-b));
} }
/** compute the volume of prism */ /** compute the volume of a prism. */
template<typename T> template<typename T>
inline float computeVolume(const T& f1,const T& f2,const T& f3, inline float computeVolume(const T& f1,const T& f2,const T& f3,
const T& b1,const T& b2,const T& b3) const T& b1,const T& b2,const T& b3)

238
include/osg/Matrixd
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -32,7 +32,6 @@ class Matrixf;
class SG_EXPORT Matrixd class SG_EXPORT Matrixd
{ {
public: public:
typedef double value_type; typedef double value_type;
@ -44,10 +43,10 @@ class SG_EXPORT Matrixd
inline explicit Matrixd( double const * const ptr ) { set(ptr); } inline explicit Matrixd( double const * const ptr ) { set(ptr); }
inline explicit Matrixd( const Quat& quat ) { set(quat); } inline explicit Matrixd( const Quat& quat ) { set(quat); }
Matrixd( value_type a00, value_type a01, value_type a02, value_type a03, Matrixd(value_type a00, value_type a01, value_type a02, value_type a03,
value_type a10, value_type a11, value_type a12, value_type a13, value_type a10, value_type a11, value_type a12, value_type a13,
value_type a20, value_type a21, value_type a22, value_type a23, value_type a20, value_type a21, value_type a22, value_type a23,
value_type a30, value_type a31, value_type a32, value_type a33); value_type a30, value_type a31, value_type a32, value_type a33);
~Matrixd() {} ~Matrixd() {}
@ -91,10 +90,10 @@ class SG_EXPORT Matrixd
for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i]; for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i];
} }
void set( value_type a00, value_type a01, value_type a02, value_type a03, void set(value_type a00, value_type a01, value_type a02,value_type a03,
value_type a10, value_type a11, value_type a12, value_type a13, value_type a10, value_type a11, value_type a12,value_type a13,
value_type a20, value_type a21, value_type a22, value_type a23, value_type a20, value_type a21, value_type a22,value_type a23,
value_type a30, value_type a31, value_type a32, value_type a33); value_type a30, value_type a31, value_type a32,value_type a33);
void set(const Quat& q); void set(const Quat& q);
@ -128,57 +127,82 @@ class SG_EXPORT Matrixd
/** Set to a orthographic projection. See glOrtho for further details.*/ /** Set to an orthographic projection.
void makeOrtho(double left, double right, * See glOrtho for further details.
*/
void makeOrtho(double left, double right,
double bottom, double top, double bottom, double top,
double zNear, double zFar); double zNear, double zFar);
/** Get the othorgraphic settings of the orthographic projection matrix. /** Get the othogrraphic settings of the orthographic projection matrix.
* Note, if matrix is not an orthographic matrix then invalid values will be returned.*/ * Note, if matrix is not an orthographic matrix then invalid values
bool getOrtho(double& left, double& right, * will be returned.
*/
bool getOrtho(double& left, double& right,
double& bottom, double& top, double& bottom, double& top,
double& zNear, double& zFar) const; double& zNear, double& zFar) const;
/** Set to a 2D orthographic projection. See glOrtho2D for further details.*/ /** Set to a 2D orthographic projection.
inline void makeOrtho2D(double left, double right, * See glOrtho2D for further details.
*/
inline void makeOrtho2D(double left, double right,
double bottom, double top) double bottom, double top)
{ {
makeOrtho(left,right,bottom,top,-1.0,1.0); makeOrtho(left,right,bottom,top,-1.0,1.0);
} }
/** Set to a perspective projection. See glFrustum for further details.*/ /** Set to a perspective projection.
void makeFrustum(double left, double right, * See glFrustum for further details.
*/
void makeFrustum(double left, double right,
double bottom, double top, double bottom, double top,
double zNear, double zFar); double zNear, double zFar);
/** Get the frustum setting of a perspective projection matrix. /** Get the frustum settings of a perspective projection matrix.
* Note, if matrix is not an perspective matrix then invalid values will be returned.*/ * Note, if matrix is not a perspective matrix then invalid values
bool getFrustum(double& left, double& right, * will be returned.
*/
bool getFrustum(double& left, double& right,
double& bottom, double& top, double& bottom, double& top,
double& zNear, double& zFar) const; double& zNear, double& zFar) const;
/** Set to a symmetrical perspective projection, See gluPerspective for further details. /** Set to a symmetrical perspective projection.
* Aspect ratio is defined as width/height.*/ * See gluPerspective for further details.
void makePerspective(double fovy,double aspectRatio, * Aspect ratio is defined as width/height.
*/
void makePerspective(double fovy, double aspectRatio,
double zNear, double zFar); double zNear, double zFar);
/** Get the frustum setting of a symetric perspective projection matrix. /** Get the frustum settings of a symmetric perspective projection
* Returns false if matrix is not a perspective matrix, where parameter values are undefined. * matrix.
* Note, if matrix is not a symetric perspective matrix then the shear will be lost. * Return false if matrix is not a perspective matrix,
* Asymetric metrices occur when stereo, power walls, caves and reality center display are used. * where parameter values are undefined.
* In these configuration one should use the AsFrustum method instead.*/ * Note, if matrix is not a symmetric perspective matrix then the
bool getPerspective(double& fovy,double& aspectRatio, * shear will be lost.
* Asymmetric matrices occur when stereo, power walls, caves and
* reality center display are used.
* In these configuration one should use the AsFrustum method instead.
*/
bool getPerspective(double& fovy, double& aspectRatio,
double& zNear, double& zFar) const; double& zNear, double& zFar) const;
/** Set to the position and orientation modelview matrix, using the same convention as gluLookAt. */ /** Set the position and orientation to be a view matrix,
* using the same convention as gluLookAt.
*/
void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up); void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */ /** Get to the position and orientation of a modelview matrix,
void getLookAt(Vec3f& eye,Vec3f& center,Vec3f& up,value_type lookDistance=1.0f) const; * using the same convention as gluLookAt.
*/
void getLookAt(Vec3f& eye,Vec3f& center,Vec3f& up,
value_type lookDistance=1.0f) const;
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */ /** Get to the position and orientation of a modelview matrix,
void getLookAt(Vec3d& eye,Vec3d& center,Vec3d& up,value_type lookDistance=1.0f) const; * using the same convention as gluLookAt.
*/
void getLookAt(Vec3d& eye,Vec3d& center,Vec3d& up,
value_type lookDistance=1.0f) const;
/** invert the matrix rhs. */ /** invert the matrix rhs. */
bool invert( const Matrixd& rhs); bool invert( const Matrixd& rhs);
@ -189,8 +213,8 @@ class SG_EXPORT Matrixd
/** full 4x4 matrix invert. */ /** full 4x4 matrix invert. */
bool invert_4x4_new( const Matrixd& ); bool invert_4x4_new( const Matrixd& );
//basic utility functions to create new matrices // basic utility functions to create new matrices
inline static Matrixd identity( void ); inline static Matrixd identity( void );
inline static Matrixd scale( const Vec3f& sv); inline static Matrixd scale( const Vec3f& sv);
inline static Matrixd scale( const Vec3d& sv); inline static Matrixd scale( const Vec3d& sv);
inline static Matrixd scale( value_type sx, value_type sy, value_type sz); inline static Matrixd scale( value_type sx, value_type sy, value_type sz);
@ -211,32 +235,46 @@ class SG_EXPORT Matrixd
inline static Matrixd rotate( const Quat& quat); inline static Matrixd rotate( const Quat& quat);
inline static Matrixd inverse( const Matrixd& matrix); inline static Matrixd inverse( const Matrixd& matrix);
/** Create a orthographic projection. See glOrtho for further details.*/ /** Create an orthographic projection matrix.
inline static Matrixd ortho(double left, double right, * See glOrtho for further details.
double bottom, double top, */
double zNear, double zFar); inline static Matrixd ortho(double left, double right,
double bottom, double top,
double zNear, double zFar);
/** Create a 2D orthographic projection. See glOrtho for further details.*/ /** Create a 2D orthographic projection.
inline static Matrixd ortho2D(double left, double right, * See glOrtho for further details.
double bottom, double top); */
inline static Matrixd ortho2D(double left, double right,
double bottom, double top);
/** Create a perspective projection. See glFrustum for further details.*/ /** Create a perspective projection.
inline static Matrixd frustum(double left, double right, * See glFrustum for further details.
double bottom, double top, */
double zNear, double zFar); inline static Matrixd frustum(double left, double right,
double bottom, double top,
double zNear, double zFar);
/** Create a symmetrical perspective projection, See gluPerspective for further details. /** Create a symmetrical perspective projection.
* Aspect ratio is defined as width/height.*/ * See gluPerspective for further details.
inline static Matrixd perspective(double fovy,double aspectRatio, * Aspect ratio is defined as width/height.
double zNear, double zFar); */
inline static Matrixd perspective(double fovy, double aspectRatio,
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */ double zNear, double zFar);
inline static Matrixd lookAt(const Vec3f& eye,const Vec3f& center,const Vec3f& up);
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */
inline static Matrixd lookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);
/** Create the position and orientation as per a camera,
* using the same convention as gluLookAt.
*/
inline static Matrixd lookAt(const Vec3f& eye,
const Vec3f& center,
const Vec3f& up);
/** Create the position and orientation as per a camera,
* using the same convention as gluLookAt.
*/
inline static Matrixd lookAt(const Vec3d& eye,
const Vec3d& center,
const Vec3d& up);
inline Vec3f preMult( const Vec3f& v ) const; inline Vec3f preMult( const Vec3f& v ) const;
inline Vec3d preMult( const Vec3d& v ) const; inline Vec3d preMult( const Vec3d& v ) const;
@ -259,17 +297,17 @@ class SG_EXPORT Matrixd
inline Vec3d getScale() const { return Vec3d(_mat[0][0],_mat[1][1],_mat[2][2]); } inline Vec3d getScale() const { return Vec3d(_mat[0][0],_mat[1][1],_mat[2][2]); }
/** apply apply an 3x3 transform of v*M[0..2,0..2] */ /** apply a 3x3 transform of v*M[0..2,0..2]. */
inline static Vec3f transform3x3(const Vec3f& v,const Matrixd& m); inline static Vec3f transform3x3(const Vec3f& v,const Matrixd& m);
/** apply apply an 3x3 transform of v*M[0..2,0..2] */ /** apply a 3x3 transform of v*M[0..2,0..2]. */
inline static Vec3d transform3x3(const Vec3d& v,const Matrixd& m); inline static Vec3d transform3x3(const Vec3d& v,const Matrixd& m);
/** apply apply an 3x3 transform of M[0..2,0..2]*v */ /** apply a 3x3 transform of M[0..2,0..2]*v. */
inline static Vec3f transform3x3(const Matrixd& m,const Vec3f& v); inline static Vec3f transform3x3(const Matrixd& m,const Vec3f& v);
/** apply apply an 3x3 transform of M[0..2,0..2]*v */ /** apply a 3x3 transform of M[0..2,0..2]*v. */
inline static Vec3d transform3x3(const Matrixd& m,const Vec3d& v); inline static Vec3d transform3x3(const Matrixd& m,const Vec3d& v);
// basic Matrixd multiplication, our workhorse methods. // basic Matrixd multiplication, our workhorse methods.
void mult( const Matrixd&, const Matrixd& ); void mult( const Matrixd&, const Matrixd& );
@ -285,11 +323,11 @@ class SG_EXPORT Matrixd
} }
inline Matrixd operator * ( const Matrixd &m ) const inline Matrixd operator * ( const Matrixd &m ) const
{ {
osg::Matrixd r; osg::Matrixd r;
r.mult(*this,m); r.mult(*this,m);
return r; return r;
} }
protected: protected:
value_type _mat[4][4]; value_type _mat[4][4];
@ -310,9 +348,9 @@ class RefMatrixd : public Object, public Matrixd
Matrixd::value_type a20, Matrixd::value_type a21, Matrixd::value_type a22, Matrixd::value_type a23, Matrixd::value_type a20, Matrixd::value_type a21, Matrixd::value_type a22, Matrixd::value_type a23,
Matrixd::value_type a30, Matrixd::value_type a31, Matrixd::value_type a32, Matrixd::value_type a33): Matrixd::value_type a30, Matrixd::value_type a31, Matrixd::value_type a32, Matrixd::value_type a33):
Matrixd(a00, a01, a02, a03, Matrixd(a00, a01, a02, a03,
a10, a11, a12, a13, a10, a11, a12, a13,
a20, a21, a22, a23, a20, a21, a22, a23,
a30, a31, a32, a33) {} a30, a31, a32, a33) {}
virtual Object* cloneType() const { return new RefMatrixd(); } virtual Object* cloneType() const { return new RefMatrixd(); }
virtual Object* clone(const CopyOp&) const { return new RefMatrixd(*this); } virtual Object* clone(const CopyOp&) const { return new RefMatrixd(*this); }
@ -327,7 +365,7 @@ class RefMatrixd : public Object, public Matrixd
}; };
//static utility methods // static utility methods
inline Matrixd Matrixd::identity(void) inline Matrixd Matrixd::identity(void)
{ {
Matrixd m; Matrixd m;
@ -392,16 +430,16 @@ inline Matrixd Matrixd::rotate(value_type angle, const Vec3d& axis )
return m; return m;
} }
inline Matrixd Matrixd::rotate( value_type angle1, const Vec3f& axis1, inline Matrixd Matrixd::rotate( value_type angle1, const Vec3f& axis1,
value_type angle2, const Vec3f& axis2, value_type angle2, const Vec3f& axis2,
value_type angle3, const Vec3f& axis3) value_type angle3, const Vec3f& axis3)
{ {
Matrixd m; Matrixd m;
m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3); m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
return m; return m;
} }
inline Matrixd Matrixd::rotate( value_type angle1, const Vec3d& axis1, inline Matrixd Matrixd::rotate( value_type angle1, const Vec3d& axis1,
value_type angle2, const Vec3d& axis2, value_type angle2, const Vec3d& axis2,
value_type angle3, const Vec3d& axis3) value_type angle3, const Vec3d& axis3)
{ {
Matrixd m; Matrixd m;
m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3); m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
@ -427,16 +465,16 @@ inline Matrixd Matrixd::inverse( const Matrixd& matrix)
return m; return m;
} }
inline Matrixd Matrixd::ortho(double left, double right, inline Matrixd Matrixd::ortho(double left, double right,
double bottom, double top, double bottom, double top,
double zNear, double zFar) double zNear, double zFar)
{ {
Matrixd m; Matrixd m;
m.makeOrtho(left,right,bottom,top,zNear,zFar); m.makeOrtho(left,right,bottom,top,zNear,zFar);
return m; return m;
} }
inline Matrixd Matrixd::ortho2D(double left, double right, inline Matrixd Matrixd::ortho2D(double left, double right,
double bottom, double top) double bottom, double top)
{ {
Matrixd m; Matrixd m;
@ -444,31 +482,35 @@ inline Matrixd Matrixd::ortho2D(double left, double right,
return m; return m;
} }
inline Matrixd Matrixd::frustum(double left, double right, inline Matrixd Matrixd::frustum(double left, double right,
double bottom, double top, double bottom, double top,
double zNear, double zFar) double zNear, double zFar)
{ {
Matrixd m; Matrixd m;
m.makeFrustum(left,right,bottom,top,zNear,zFar); m.makeFrustum(left,right,bottom,top,zNear,zFar);
return m; return m;
} }
inline Matrixd Matrixd::perspective(double fovy,double aspectRatio, inline Matrixd Matrixd::perspective(double fovy, double aspectRatio,
double zNear, double zFar) double zNear, double zFar)
{ {
Matrixd m; Matrixd m;
m.makePerspective(fovy,aspectRatio,zNear,zFar); m.makePerspective(fovy,aspectRatio,zNear,zFar);
return m; return m;
} }
inline Matrixd Matrixd::lookAt(const Vec3f& eye,const Vec3f& center,const Vec3f& up) inline Matrixd Matrixd::lookAt(const Vec3f& eye,
const Vec3f& center,
const Vec3f& up)
{ {
Matrixd m; Matrixd m;
m.makeLookAt(eye,center,up); m.makeLookAt(eye,center,up);
return m; return m;
} }
inline Matrixd Matrixd::lookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up) inline Matrixd Matrixd::lookAt(const Vec3d& eye,
const Vec3d& center,
const Vec3d& up)
{ {
Matrixd m; Matrixd m;
m.makeLookAt(eye,center,up); m.makeLookAt(eye,center,up);
@ -482,6 +524,7 @@ inline Vec3f Matrixd::postMult( const Vec3f& v ) const
(_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d, (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
(_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ; (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
} }
inline Vec3d Matrixd::postMult( const Vec3d& v ) const inline Vec3d Matrixd::postMult( const Vec3d& v ) const
{ {
value_type d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ; value_type d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
@ -497,6 +540,7 @@ inline Vec3f Matrixd::preMult( const Vec3f& v ) const
(_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d, (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d); (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
} }
inline Vec3d Matrixd::preMult( const Vec3d& v ) const inline Vec3d Matrixd::preMult( const Vec3d& v ) const
{ {
value_type d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ; value_type d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
@ -527,6 +571,7 @@ inline Vec4f Matrixd::preMult( const Vec4f& v ) const
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()), (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
(_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w())); (_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
} }
inline Vec4d Matrixd::preMult( const Vec4d& v ) const inline Vec4d Matrixd::preMult( const Vec4d& v ) const
{ {
return Vec4d( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()), return Vec4d( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
@ -534,6 +579,7 @@ inline Vec4d Matrixd::preMult( const Vec4d& v ) const
(_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()), (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
(_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w())); (_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
} }
inline Vec3f Matrixd::transform3x3(const Vec3f& v,const Matrixd& m) inline Vec3f Matrixd::transform3x3(const Vec3f& v,const Matrixd& m)
{ {
return Vec3f( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()), return Vec3f( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
@ -560,19 +606,21 @@ inline Vec3d Matrixd::transform3x3(const Matrixd& m,const Vec3d& v)
(m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ; (m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
} }
inline Vec3f operator* (const Vec3f& v, const Matrixd& m ) inline Vec3f operator* (const Vec3f& v, const Matrixd& m )
{ {
return m.preMult(v); return m.preMult(v);
} }
inline Vec3d operator* (const Vec3d& v, const Matrixd& m ) inline Vec3d operator* (const Vec3d& v, const Matrixd& m )
{ {
return m.preMult(v); return m.preMult(v);
} }
inline Vec4f operator* (const Vec4f& v, const Matrixd& m ) inline Vec4f operator* (const Vec4f& v, const Matrixd& m )
{ {
return m.preMult(v); return m.preMult(v);
} }
inline Vec4d operator* (const Vec4d& v, const Matrixd& m ) inline Vec4d operator* (const Vec4d& v, const Matrixd& m )
{ {
return m.preMult(v); return m.preMult(v);
@ -582,14 +630,17 @@ inline Vec3f Matrixd::operator* (const Vec3f& v) const
{ {
return postMult(v); return postMult(v);
} }
inline Vec3d Matrixd::operator* (const Vec3d& v) const inline Vec3d Matrixd::operator* (const Vec3d& v) const
{ {
return postMult(v); return postMult(v);
} }
inline Vec4f Matrixd::operator* (const Vec4f& v) const inline Vec4f Matrixd::operator* (const Vec4f& v) const
{ {
return postMult(v); return postMult(v);
} }
inline Vec4d Matrixd::operator* (const Vec4d& v) const inline Vec4d Matrixd::operator* (const Vec4d& v) const
{ {
return postMult(v); return postMult(v);
@ -608,7 +659,6 @@ inline std::ostream& operator<< (std::ostream& os, const Matrixd& m )
return os; return os;
} }
} //namespace osg } //namespace osg

170
include/osg/Matrixf
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
* *
* This library is open source and may be redistributed and/or modified under * This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
@ -28,11 +28,10 @@
namespace osg { namespace osg {
class Matrixd; class Matrixf;
class SG_EXPORT Matrixf class SG_EXPORT Matrixf
{ {
public: public:
typedef float value_type; typedef float value_type;
@ -91,10 +90,10 @@ class SG_EXPORT Matrixf
for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i]; for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i];
} }
void set( value_type a00, value_type a01, value_type a02, value_type a03, void set(value_type a00, value_type a01, value_type a02,value_type a03,
value_type a10, value_type a11, value_type a12, value_type a13, value_type a10, value_type a11, value_type a12,value_type a13,
value_type a20, value_type a21, value_type a22, value_type a23, value_type a20, value_type a21, value_type a22,value_type a23,
value_type a30, value_type a31, value_type a32, value_type a33); value_type a30, value_type a31, value_type a32,value_type a33);
void set(const Quat& q); void set(const Quat& q);
@ -128,57 +127,82 @@ class SG_EXPORT Matrixf
/** Set to a orthographic projection. See glOrtho for further details.*/ /** Set to an orthographic projection.
void makeOrtho(double left, double right, * See glOrtho for further details.
*/
void makeOrtho(double left, double right,
double bottom, double top, double bottom, double top,
double zNear, double zFar); double zNear, double zFar);
/** Get the othorgraphic settings of the orthographic projection matrix. /** Get the othogrraphic settings of the orthographic projection matrix.
* Note, if matrix is not an orthographic matrix then invalid values will be returned.*/ * Note, if matrix is not an orthographic matrix then invalid values
bool getOrtho(double& left, double& right, * will be returned.
*/
bool getOrtho(double& left, double& right,
double& bottom, double& top, double& bottom, double& top,
double& zNear, double& zFar) const; double& zNear, double& zFar) const;
/** Set to a 2D orthographic projection. See glOrtho2D for further details.*/ /** Set to a 2D orthographic projection.
inline void makeOrtho2D(double left, double right, * See glOrtho2D for further details.
*/
inline void makeOrtho2D(double left, double right,
double bottom, double top) double bottom, double top)
{ {
makeOrtho(left,right,bottom,top,-1.0,1.0); makeOrtho(left,right,bottom,top,-1.0,1.0);
} }
/** Set to a perspective projection. See glFrustum for further details.*/ /** Set to a perspective projection.
void makeFrustum(double left, double right, * See glFrustum for further details.
*/
void makeFrustum(double left, double right,
double bottom, double top, double bottom, double top,
double zNear, double zFar); double zNear, double zFar);
/** Get the frustum setting of a perspective projection matrix. /** Get the frustum settings of a perspective projection matrix.
* Note, if matrix is not an perspective matrix then invalid values will be returned.*/ * Note, if matrix is not a perspective matrix then invalid values
bool getFrustum(double& left, double& right, * will be returned.
*/
bool getFrustum(double& left, double& right,
double& bottom, double& top, double& bottom, double& top,
double& zNear, double& zFar) const; double& zNear, double& zFar) const;
/** Set to a symmetrical perspective projection, See gluPerspective for further details. /** Set to a symmetrical perspective projection.
* Aspect ratio is defined as width/height.*/ * See gluPerspective for further details.
void makePerspective(double fovy,double aspectRatio, * Aspect ratio is defined as width/height.
*/
void makePerspective(double fovy, double aspectRatio,
double zNear, double zFar); double zNear, double zFar);
/** Get the frustum setting of a symetric perspective projection matrix. /** Get the frustum settings of a symmetric perspective projection
* Returns false if matrix is not a perspective matrix, where parameter values are undefined. * matrix.
* Note, if matrix is not a symetric perspective matrix then the shear will be lost. * Return false if matrix is not a perspective matrix,
* Asymetric metrices occur when stereo, power walls, caves and reality center display are used. * where parameter values are undefined.
* In these configuration one should use the AsFrustum method instead.*/ * Note, if matrix is not a symmetric perspective matrix then the
bool getPerspective(double& fovy,double& aspectRatio, * shear will be lost.
* Asymmetric matrices occur when stereo, power walls, caves and
* reality center display are used.
* In these configuration one should use the AsFrustum method instead.
*/
bool getPerspective(double& fovy, double& aspectRatio,
double& zNear, double& zFar) const; double& zNear, double& zFar) const;
/** Set to the position and orientation modelview matrix, using the same convention as gluLookAt. */ /** Set the position and orientation to be a view matrix,
* using the same convention as gluLookAt.
*/
void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up); void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */ /** Get to the position and orientation of a modelview matrix,
void getLookAt(Vec3f& eye,Vec3f& center,Vec3f& up,value_type lookDistance=1.0f) const; * using the same convention as gluLookAt.
*/
void getLookAt(Vec3f& eye,Vec3f& center,Vec3f& up,
value_type lookDistance=1.0f) const;
/** Get to the position and orientation of a modelview matrix, using the same convention as gluLookAt. */ /** Get to the position and orientation of a modelview matrix,
void getLookAt(Vec3d& eye,Vec3d& center,Vec3d& up,value_type lookDistance=1.0f) const; * using the same convention as gluLookAt.
*/
void getLookAt(Vec3d& eye,Vec3d& center,Vec3d& up,
value_type lookDistance=1.0f) const;
/** invert the matrix rhs. */ /** invert the matrix rhs. */
bool invert( const Matrixf& rhs); bool invert( const Matrixf& rhs);
@ -211,32 +235,46 @@ class SG_EXPORT Matrixf
inline static Matrixf rotate( const Quat& quat); inline static Matrixf rotate( const Quat& quat);
inline static Matrixf inverse( const Matrixf& matrix); inline static Matrixf inverse( const Matrixf& matrix);
/** Create a orthographic projection. See glOrtho for further details.*/ /** Create an orthographic projection matrix.
inline static Matrixf ortho(double left, double right, * See glOrtho for further details.
double bottom, double top, */
double zNear, double zFar); inline static Matrixf ortho(double left, double right,
double bottom, double top,
double zNear, double zFar);
/** Create a 2D orthographic projection. See glOrtho for further details.*/ /** Create a 2D orthographic projection.
inline static Matrixf ortho2D(double left, double right, * See glOrtho for further details.
double bottom, double top); */
inline static Matrixf ortho2D(double left, double right,
double bottom, double top);
/** Create a perspective projection. See glFrustum for further details.*/ /** Create a perspective projection.
inline static Matrixf frustum(double left, double right, * See glFrustum for further details.
double bottom, double top, */
double zNear, double zFar); inline static Matrixf frustum(double left, double right,
double bottom, double top,
double zNear, double zFar);
/** Create a symmetrical perspective projection, See gluPerspective for further details. /** Create a symmetrical perspective projection.
* Aspect ratio is defined as width/height.*/ * See gluPerspective for further details.
inline static Matrixf perspective(double fovy,double aspectRatio, * Aspect ratio is defined as width/height.
double zNear, double zFar); */
inline static Matrixf perspective(double fovy, double aspectRatio,
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */ double zNear, double zFar);
inline static Matrixf lookAt(const Vec3f& eye,const Vec3f& center,const Vec3f& up);
/** Create the position and orientation as per a camera, using the same convention as gluLookAt. */
inline static Matrixf lookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);
/** Create the position and orientation as per a camera,
* using the same convention as gluLookAt.
*/
inline static Matrixf lookAt(const Vec3f& eye,
const Vec3f& center,
const Vec3f& up);
/** Create the position and orientation as per a camera,
* using the same convention as gluLookAt.
*/
inline static Matrixf lookAt(const Vec3d& eye,
const Vec3d& center,
const Vec3d& up);
inline Vec3f preMult( const Vec3f& v ) const; inline Vec3f preMult( const Vec3f& v ) const;
inline Vec3d preMult( const Vec3d& v ) const; inline Vec3d preMult( const Vec3d& v ) const;
@ -259,17 +297,17 @@ class SG_EXPORT Matrixf
inline Vec3d getScale() const { return Vec3d(_mat[0][0],_mat[1][1],_mat[2][2]); } inline Vec3d getScale() const { return Vec3d(_mat[0][0],_mat[1][1],_mat[2][2]); }
/** apply apply an 3x3 transform of v*M[0..2,0..2] */ /** apply a 3x3 transform of v*M[0..2,0..2]. */
inline static Vec3f transform3x3(const Vec3f& v,const Matrixf& m); inline static Vec3f transform3x3(const Vec3f& v,const Matrixf& m);
/** apply apply an 3x3 transform of v*M[0..2,0..2] */ /** apply a 3x3 transform of v*M[0..2,0..2]. */
inline static Vec3d transform3x3(const Vec3d& v,const Matrixf& m); inline static Vec3d transform3x3(const Vec3d& v,const Matrixf& m);
/** apply apply an 3x3 transform of M[0..2,0..2]*v */ /** apply a 3x3 transform of M[0..2,0..2]*v. */
inline static Vec3f transform3x3(const Matrixf& m,const Vec3f& v); inline static Vec3f transform3x3(const Matrixf& m,const Vec3f& v);
/** apply apply an 3x3 transform of M[0..2,0..2]*v */ /** apply a 3x3 transform of M[0..2,0..2]*v. */
inline static Vec3d transform3x3(const Matrixf& m,const Vec3d& v); inline static Vec3d transform3x3(const Matrixf& m,const Vec3d& v);
// basic Matrixf multiplication, our workhorse methods. // basic Matrixf multiplication, our workhorse methods.
void mult( const Matrixf&, const Matrixf& ); void mult( const Matrixf&, const Matrixf& );