nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "std3d.h"
00027 
00028 #include "nel/3d/frustum.h"
00029 #include "nel/misc/matrix.h"
00030 #include <math.h>
00031 
00032 
00033 using namespace NLMISC;
00034 
00035 namespace NL3D
00036 {
00037 
00038 
00039 void                    CFrustum::init(float left, float right, float bottom, float top, float znear, float zfar, bool perspective)
00040 {
00041         Left= left;
00042         Right= right;
00043         Bottom= bottom;
00044         Top= top;
00045         Near= znear;
00046         Far= zfar;
00047         Perspective= perspective;
00048 }
00049 
00050 void                    CFrustum::init(float width, float height, float znear, float zfar, bool perspective)
00051 {
00052         init(-width/2, width/2, -height/2, height/2, znear, zfar, perspective);
00053 }
00054 void                    CFrustum::initPerspective(float fov, float aspectRatio, float znear, float zfar)
00055 {
00056         float   w,h;
00057         w= 2*znear*(float)tan(fov/2);
00058         h= w/aspectRatio;
00059         init(w,h,znear,zfar,true);
00060 }
00061 void                    CFrustum::getValues(float &left, float &right, float &bottom, float &top, float &znear, float &zfar) const
00062 {
00063         left= Left;
00064         right= Right;
00065         bottom= Bottom;
00066         top= Top;
00067         znear= Near;
00068         zfar= Far;
00069 }
00070 
00071 
00072 // ***************************************************************************
00073 CVector                 CFrustum::project(const CVector &vec) const
00074 {
00075         CVector         ret;
00076         float           decalX, decalY;
00077         float           w, h;
00078         float           OOw, OOh;
00079 
00080         // Fast transform to openGL like axis.
00081         CVector         pt;
00082         pt.x= vec.x;
00083         pt.y= vec.z;
00084         pt.z= -vec.y;
00085 
00086         decalX= (Right+Left);
00087         decalY= (Top+Bottom);
00088         w= Right-Left;
00089         h= Top-Bottom;
00090         OOw= 1.0f/w;
00091         OOh= 1.0f/h;
00092 
00093         // project to -1..+1.
00094         if(Perspective)
00095         {
00096                 ret.x= (2*Near*pt.x + decalX*pt.z)*OOw;
00097                 ret.x/= -pt.z;
00098                 ret.y= (2*Near*pt.y + decalY*pt.z)*OOh;
00099                 ret.y/= -pt.z;
00100         }
00101         else
00102         {
00103                 ret.x= (2*pt.x-decalX)*OOw;
00104                 ret.y= (2*pt.y-decalY)*OOh;
00105         }
00106 
00107 
00108         // Map it to 0..1.
00109         ret.x= 0.5f*(ret.x+1);
00110         ret.y= 0.5f*(ret.y+1);
00111         ret.z= 0;
00112 
00113         return ret;
00114 }
00115 
00116 
00117 
00118 // ***************************************************************************
00119 CVector                 CFrustum::unProject(const CVector &vec) const
00120 {
00121         CVector         ret;
00122         float           decalX, decalY;
00123         float           w, h;
00124         float           OOw, OOh;
00125 
00126         decalX= (Right+Left);
00127         decalY= (Top+Bottom);
00128         w= Right-Left;
00129         h= Top-Bottom;
00130         OOw= 1.0f/w;
00131         OOh= 1.0f/h;
00132 
00133         // vec is a vector in a left hand axis.
00134         CVector         pt;
00135         pt.x= vec.x;
00136         pt.y= vec.y;
00137         pt.z= vec.z;
00138         
00139         // Map it to -1..1
00140         pt.x= 2*(pt.x-0.5f);
00141         pt.y= 2*(pt.y-0.5f);
00142 
00143         // Map Z to Near..Far.
00144         // Z IN is 1/Z, and is in 0..1.
00145         // inverse to 1..0.
00146         pt.z= 1-pt.z;
00147         // Map ret.z to 1/Far..1/Near.
00148         pt.z= 1/Far+(1/Near-1/Far)*pt.z;
00149         // Inverse, so ret.z E Near..Far.
00150         pt.z= 1/pt.z;
00151         // Actually, pt.z==w, homogenous coordinate.
00152 
00153 
00154         // unproject
00155         if(Perspective)
00156         {
00157                 // w of homogenous coordinate.
00158                 float   Wh;
00159                 float   Zin;
00160                 Wh= pt.z;
00161                 Zin= -pt.z;
00162 
00163                 // unproject.  (Projection is: x'= x/w.  y'= y/w).
00164                 pt.x= pt.x*Wh;
00165                 pt.y= pt.y*Wh;
00166                 ret.x= (pt.x*w-decalX*Zin)/(2*Near);
00167                 ret.y= (pt.y*w-decalY*Zin)/(2*Near);
00168                 ret.z= Zin;
00169         }
00170         else
00171         {
00172                 // NOT DONE YET.
00173                 nlstop;
00174                 /*ret.x= (pt.x*w+decalX)/2;
00175                 ret.y= (pt.y*h+decalY)/2;
00176                 */
00177         }
00178 
00179         // Fast transform from openGL like axis.
00180         pt =ret;
00181         ret.x= pt.x;
00182         ret.y= -pt.z;
00183         ret.z= pt.y;
00184 
00185         return ret;
00186 }
00187 
00188 
00189 
00190 } // NL3D
frustum.cpp
