From f9158592e1478b2013afc7041d9ed041cf2d2f4a Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Mon, 13 Jan 2014 19:47:58 +1000 Subject: Update Irrlicht to 1.8.1. Include actual change markers this time. lol --- .../doc/html/_s_view_frustum_8h_source.html | 444 +++++++++++++++++++++ 1 file changed, 444 insertions(+) create mode 100644 libraries/irrlicht-1.8.1/doc/html/_s_view_frustum_8h_source.html (limited to 'libraries/irrlicht-1.8.1/doc/html/_s_view_frustum_8h_source.html') diff --git a/libraries/irrlicht-1.8.1/doc/html/_s_view_frustum_8h_source.html b/libraries/irrlicht-1.8.1/doc/html/_s_view_frustum_8h_source.html new file mode 100644 index 0000000..bfcab04 --- /dev/null +++ b/libraries/irrlicht-1.8.1/doc/html/_s_view_frustum_8h_source.html @@ -0,0 +1,444 @@ + + + + +Irrlicht 3D Engine: SViewFrustum.h Source File + + + + + + + + + + + + + + +
+ + +
+ + + + + + + + + + + + + + + + + +
+
Irrlicht 3D Engine + +
+ +
+ + + + + + +
+
+
+ + + + +
+
+ +
+
+
+ +
+
+
+
SViewFrustum.h
+
+
+Go to the documentation of this file.
00001 // Copyright (C) 2002-2012 Nikolaus Gebhardt
+00002 // This file is part of the "Irrlicht Engine".
+00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
+00004 
+00005 #ifndef __S_VIEW_FRUSTUM_H_INCLUDED__
+00006 #define __S_VIEW_FRUSTUM_H_INCLUDED__
+00007 
+00008 #include "plane3d.h"
+00009 #include "vector3d.h"
+00010 #include "line3d.h"
+00011 #include "aabbox3d.h"
+00012 #include "matrix4.h"
+00013 #include "IVideoDriver.h"
+00014 
+00015 namespace irr
+00016 {
+00017 namespace scene
+00018 {
+00019 
+00021 
+00025     struct SViewFrustum
+00026     {
+00027         enum VFPLANES
+00028         {
+00030             VF_FAR_PLANE = 0,
+00032             VF_NEAR_PLANE,
+00034             VF_LEFT_PLANE,
+00036             VF_RIGHT_PLANE,
+00038             VF_BOTTOM_PLANE,
+00040             VF_TOP_PLANE,
+00041 
+00043             VF_PLANE_COUNT
+00044         };
+00045 
+00046 
+00048         SViewFrustum() {}
+00049 
+00051         SViewFrustum(const SViewFrustum& other);
+00052 
+00054         SViewFrustum(const core::matrix4& mat);
+00055 
+00057         inline void setFrom(const core::matrix4& mat);
+00058 
+00060 
+00061         void transform(const core::matrix4& mat);
+00062 
+00064         core::vector3df getFarLeftUp() const;
+00065 
+00067         core::vector3df getFarLeftDown() const;
+00068 
+00070         core::vector3df getFarRightUp() const;
+00071 
+00073         core::vector3df getFarRightDown() const;
+00074 
+00076         core::vector3df getNearLeftUp() const;
+00077 
+00079         core::vector3df getNearLeftDown() const;
+00080 
+00082         core::vector3df getNearRightUp() const;
+00083 
+00085         core::vector3df getNearRightDown() const;
+00086 
+00088         const core::aabbox3d<f32> &getBoundingBox() const;
+00089 
+00091         inline void recalculateBoundingBox();
+00092 
+00094         core::matrix4& getTransform( video::E_TRANSFORMATION_STATE state);
+00095 
+00097         const core::matrix4& getTransform( video::E_TRANSFORMATION_STATE state) const;
+00098 
+00100 
+00101         bool clipLine(core::line3d<f32>& line) const;
+00102 
+00104         core::vector3df cameraPosition;
+00105 
+00107         core::plane3d<f32> planes[VF_PLANE_COUNT];
+00108 
+00110         core::aabbox3d<f32> boundingBox;
+00111 
+00112     private:
+00114         enum E_TRANSFORMATION_STATE_FRUSTUM
+00115         {
+00116             ETS_VIEW = 0,
+00117             ETS_PROJECTION = 1,
+00118             ETS_COUNT_FRUSTUM
+00119         };
+00120 
+00122         core::matrix4 Matrices[ETS_COUNT_FRUSTUM];
+00123     };
+00124 
+00125 
+00129     inline SViewFrustum::SViewFrustum(const SViewFrustum& other)
+00130     {
+00131         cameraPosition=other.cameraPosition;
+00132         boundingBox=other.boundingBox;
+00133 
+00134         u32 i;
+00135         for (i=0; i<VF_PLANE_COUNT; ++i)
+00136             planes[i]=other.planes[i];
+00137 
+00138         for (i=0; i<ETS_COUNT_FRUSTUM; ++i)
+00139             Matrices[i]=other.Matrices[i];
+00140     }
+00141 
+00142     inline SViewFrustum::SViewFrustum(const core::matrix4& mat)
+00143     {
+00144         setFrom ( mat );
+00145     }
+00146 
+00147 
+00148     inline void SViewFrustum::transform(const core::matrix4& mat)
+00149     {
+00150         for (u32 i=0; i<VF_PLANE_COUNT; ++i)
+00151             mat.transformPlane(planes[i]);
+00152 
+00153         mat.transformVect(cameraPosition);
+00154         recalculateBoundingBox();
+00155     }
+00156 
+00157 
+00158     inline core::vector3df SViewFrustum::getFarLeftUp() const
+00159     {
+00160         core::vector3df p;
+00161         planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
+00162             planes[scene::SViewFrustum::VF_TOP_PLANE],
+00163             planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
+00164 
+00165         return p;
+00166     }
+00167 
+00168     inline core::vector3df SViewFrustum::getFarLeftDown() const
+00169     {
+00170         core::vector3df p;
+00171         planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
+00172             planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
+00173             planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
+00174 
+00175         return p;
+00176     }
+00177 
+00178     inline core::vector3df SViewFrustum::getFarRightUp() const
+00179     {
+00180         core::vector3df p;
+00181         planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
+00182             planes[scene::SViewFrustum::VF_TOP_PLANE],
+00183             planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
+00184 
+00185         return p;
+00186     }
+00187 
+00188     inline core::vector3df SViewFrustum::getFarRightDown() const
+00189     {
+00190         core::vector3df p;
+00191         planes[scene::SViewFrustum::VF_FAR_PLANE].getIntersectionWithPlanes(
+00192             planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
+00193             planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
+00194 
+00195         return p;
+00196     }
+00197 
+00198     inline core::vector3df SViewFrustum::getNearLeftUp() const
+00199     {
+00200         core::vector3df p;
+00201         planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
+00202             planes[scene::SViewFrustum::VF_TOP_PLANE],
+00203             planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
+00204 
+00205         return p;
+00206     }
+00207 
+00208     inline core::vector3df SViewFrustum::getNearLeftDown() const
+00209     {
+00210         core::vector3df p;
+00211         planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
+00212             planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
+00213             planes[scene::SViewFrustum::VF_LEFT_PLANE], p);
+00214 
+00215         return p;
+00216     }
+00217 
+00218     inline core::vector3df SViewFrustum::getNearRightUp() const
+00219     {
+00220         core::vector3df p;
+00221         planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
+00222             planes[scene::SViewFrustum::VF_TOP_PLANE],
+00223             planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
+00224 
+00225         return p;
+00226     }
+00227 
+00228     inline core::vector3df SViewFrustum::getNearRightDown() const
+00229     {
+00230         core::vector3df p;
+00231         planes[scene::SViewFrustum::VF_NEAR_PLANE].getIntersectionWithPlanes(
+00232             planes[scene::SViewFrustum::VF_BOTTOM_PLANE],
+00233             planes[scene::SViewFrustum::VF_RIGHT_PLANE], p);
+00234 
+00235         return p;
+00236     }
+00237 
+00238     inline const core::aabbox3d<f32> &SViewFrustum::getBoundingBox() const
+00239     {
+00240         return boundingBox;
+00241     }
+00242 
+00243     inline void SViewFrustum::recalculateBoundingBox()
+00244     {
+00245         boundingBox.reset ( cameraPosition );
+00246 
+00247         boundingBox.addInternalPoint(getFarLeftUp());
+00248         boundingBox.addInternalPoint(getFarRightUp());
+00249         boundingBox.addInternalPoint(getFarLeftDown());
+00250         boundingBox.addInternalPoint(getFarRightDown());
+00251     }
+00252 
+00255     inline void SViewFrustum::setFrom(const core::matrix4& mat)
+00256     {
+00257         // left clipping plane
+00258         planes[VF_LEFT_PLANE].Normal.X = mat[3 ] + mat[0];
+00259         planes[VF_LEFT_PLANE].Normal.Y = mat[7 ] + mat[4];
+00260         planes[VF_LEFT_PLANE].Normal.Z = mat[11] + mat[8];
+00261         planes[VF_LEFT_PLANE].D =        mat[15] + mat[12];
+00262 
+00263         // right clipping plane
+00264         planes[VF_RIGHT_PLANE].Normal.X = mat[3 ] - mat[0];
+00265         planes[VF_RIGHT_PLANE].Normal.Y = mat[7 ] - mat[4];
+00266         planes[VF_RIGHT_PLANE].Normal.Z = mat[11] - mat[8];
+00267         planes[VF_RIGHT_PLANE].D =        mat[15] - mat[12];
+00268 
+00269         // top clipping plane
+00270         planes[VF_TOP_PLANE].Normal.X = mat[3 ] - mat[1];
+00271         planes[VF_TOP_PLANE].Normal.Y = mat[7 ] - mat[5];
+00272         planes[VF_TOP_PLANE].Normal.Z = mat[11] - mat[9];
+00273         planes[VF_TOP_PLANE].D =        mat[15] - mat[13];
+00274 
+00275         // bottom clipping plane
+00276         planes[VF_BOTTOM_PLANE].Normal.X = mat[3 ] + mat[1];
+00277         planes[VF_BOTTOM_PLANE].Normal.Y = mat[7 ] + mat[5];
+00278         planes[VF_BOTTOM_PLANE].Normal.Z = mat[11] + mat[9];
+00279         planes[VF_BOTTOM_PLANE].D =        mat[15] + mat[13];
+00280 
+00281         // far clipping plane
+00282         planes[VF_FAR_PLANE].Normal.X = mat[3 ] - mat[2];
+00283         planes[VF_FAR_PLANE].Normal.Y = mat[7 ] - mat[6];
+00284         planes[VF_FAR_PLANE].Normal.Z = mat[11] - mat[10];
+00285         planes[VF_FAR_PLANE].D =        mat[15] - mat[14];
+00286 
+00287         // near clipping plane
+00288         planes[VF_NEAR_PLANE].Normal.X = mat[2];
+00289         planes[VF_NEAR_PLANE].Normal.Y = mat[6];
+00290         planes[VF_NEAR_PLANE].Normal.Z = mat[10];
+00291         planes[VF_NEAR_PLANE].D =        mat[14];
+00292 
+00293         // normalize normals
+00294         u32 i;
+00295         for ( i=0; i != VF_PLANE_COUNT; ++i)
+00296         {
+00297             const f32 len = -core::reciprocal_squareroot(
+00298                     planes[i].Normal.getLengthSQ());
+00299             planes[i].Normal *= len;
+00300             planes[i].D *= len;
+00301         }
+00302 
+00303         // make bounding box
+00304         recalculateBoundingBox();
+00305     }
+00306 
+00310     inline core::matrix4& SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state )
+00311     {
+00312         u32 index = 0;
+00313         switch ( state )
+00314         {
+00315             case video::ETS_PROJECTION:
+00316                 index = SViewFrustum::ETS_PROJECTION; break;
+00317             case video::ETS_VIEW:
+00318                 index = SViewFrustum::ETS_VIEW; break;
+00319             default:
+00320                 break;
+00321         }
+00322         return Matrices [ index ];
+00323     }
+00324 
+00328     inline const core::matrix4& SViewFrustum::getTransform(video::E_TRANSFORMATION_STATE state ) const
+00329     {
+00330         u32 index = 0;
+00331         switch ( state )
+00332         {
+00333             case video::ETS_PROJECTION:
+00334                 index = SViewFrustum::ETS_PROJECTION; break;
+00335             case video::ETS_VIEW:
+00336                 index = SViewFrustum::ETS_VIEW; break;
+00337             default:
+00338                 break;
+00339         }
+00340         return Matrices [ index ];
+00341     }
+00342 
+00344     inline bool SViewFrustum::clipLine(core::line3d<f32>& line) const
+00345     {
+00346         bool wasClipped = false;
+00347         for (u32 i=0; i < VF_PLANE_COUNT; ++i)
+00348         {
+00349             if (planes[i].classifyPointRelation(line.start) == core::ISREL3D_FRONT)
+00350             {
+00351                 line.start = line.start.getInterpolated(line.end,
+00352                         planes[i].getKnownIntersectionWithLine(line.start, line.end));
+00353                 wasClipped = true;
+00354             }
+00355             if (planes[i].classifyPointRelation(line.end) == core::ISREL3D_FRONT)
+00356             {
+00357                 line.end = line.start.getInterpolated(line.end,
+00358                         planes[i].getKnownIntersectionWithLine(line.start, line.end));
+00359                 wasClipped = true;
+00360             }
+00361         }
+00362         return wasClipped;
+00363     }
+00364 
+00365 
+00366 } // end namespace scene
+00367 } // end namespace irr
+00368 
+00369 #endif
+00370 
+
+
+ + + + + -- cgit v1.1