SO3Engine: SO3Engine/SCOLPack/SCOLCamera.cpp Source File

00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OpenSpace3D
00004 For the latest info, see http://www.openspace3d.com
00005 
00006 Copyright (c) 2010 I-maginer
00007 
00008 This program is free software; you can redistribute it and/or modify it under
00009 the terms of the GNU Lesser General Public License as published by the Free Software
00010 Foundation; either version 2 of the License, or (at your option) any later
00011 version.
00012 
00013 This program is distributed in the hope that it will be useful, but WITHOUT
00014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00016 
00017 You should have received a copy of the GNU Lesser General Public License along with
00018 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00019 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00020 http://www.gnu.org/copyleft/lesser.txt
00021 
00022 You may alternatively use this source under the terms of a specific version of
00023 the OpenSpace3D Unrestricted License provided you have obtained such a license from
00024 I-maginer.
00025 -----------------------------------------------------------------------------
00026 */
00027 
00028 
00036 
00037 #include        "SO3SCOL.h"
00038 
00039 // Material includes
00040 #include "../SO3Material/SO3Compositor.h"
00041 
00042 // Renderer includes
00043 #include "../SO3Renderer/SO3Viewport.h"
00044 
00045 // Scene Graph includes
00046 #include "../SO3SceneGraph/SO3Camera.h"
00047 #include "../SO3SceneGraph/SO3Entity.h"
00048 #include "../SO3SceneGraph/SO3Scene.h"
00049 
00050 
00060 int SO3CameraCreate(mmachine m)
00061 {
00062 #ifdef SO3_DEBUG
00063         MMechostr(MSKDEBUG, "SO3CameraCreate\n");
00064 #endif
00065         int name = MMpull(m);
00066   int s = MMget(m, 0);
00067   if (s==NIL)
00068   {
00069     MMset(m, 0, NIL);
00070     return 0;
00071   }
00072 
00073   SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00074   if (scene==NULL)
00075   {
00076     MMset(m, 0, NIL);
00077     return 0;
00078   }
00079         
00080   // Create Node
00081   std::string tmpCameraName(MMstartstr(m, MTOP(name)));
00082         SCamera* cam = 0;
00083   try
00084         {
00085     cam = scene->CreateCamera(tmpCameraName);
00086         }
00087   catch(Ogre::Exception &e)
00088         { 
00089                 MMechostr(MSKDEBUG,"An exception has occurred : %s\n",e.what());
00090                 MMset(m, 0, NIL);               
00091                 return 0;       
00092         }
00093 
00094   // remove last param
00095   MMpull(m);
00096         return createObject(m, cam, scene);
00097 }
00098 
00099 
00109 int SO3CameraLookAt(mmachine m)
00110 {
00111 #ifdef SO3_DEBUG
00112         MMechostr(MSKDEBUG, "SO3CameraLookAt\n");
00113 #endif
00114 
00115   int vec = MMpull(m);
00116   int cam = MMget(m, 0); 
00117   if((cam==NIL)||(vec==NIL))
00118   {
00119     MMset(m, 0, NIL);           
00120     return 0;   
00121   }
00122 
00123   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00124   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00125   {
00126     MMset(m, 0, NIL);
00127     return 0;
00128   }
00129 
00130   SCamera* camera = static_cast<SCamera*>(node);
00131 
00132         if((MMfetch(m,MTOP(vec),0)==NIL) || (MMfetch(m,MTOP(vec),1)==NIL) || (MMfetch(m,MTOP(vec),2)==NIL))             
00133   {
00134     MMset(m, 0, NIL);   
00135     return 0;
00136   }
00137 
00138   Ogre::Vector3 vecteur(MTOF(MMfetch(m, MTOP(vec), 0)),
00139                                MTOF(MMfetch(m, MTOP(vec), 1)),
00140                                MTOF(MMfetch(m, MTOP(vec), 2)));
00141 
00142   // TODO: lookat in SNode or SCamera
00143   camera->GetOgreCameraPointer()->lookAt(vecteur);
00144 
00145   MMset(m, 0, ITOM(1));
00146 
00147         return 0;
00148 }
00149 
00150 
00159 int SO3CameraGetDirection(mmachine m)
00160 {
00161 #ifdef SO3_DEBUG
00162         MMechostr(MSKDEBUG, "SO3CameraGetDirection\n");
00163 #endif
00164 
00165   int cam = MMget(m, 0);
00166         if(cam==NIL)    
00167   {
00168     MMset(m, 0, NIL);
00169     return 0;
00170   }
00171 
00172   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00173   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00174   {
00175     MMset(m, 0, NIL);
00176     return 0;
00177   }
00178   
00179   SCamera* camera = static_cast<SCamera*>(node);
00180         
00181   // TODO: GetDirection in SNode or SCamera
00182   Ogre::Vector3 vecteur(camera->GetOgreCameraPointer()->getDirection());
00183         int tuple = MMmalloc(m, 3, TYPETAB);
00184         if(tuple==NIL)
00185   {     
00186     MMset(m, 0, NIL);
00187     return MERRMEM;
00188   }
00189         
00190   MMstore(m, tuple, 0, FTOM((vecteur.x)));
00191         MMstore(m, tuple, 1, FTOM((vecteur.y)));
00192         MMstore(m, tuple, 2, FTOM((vecteur.z)));
00193   MMset(m, 0, PTOM(tuple));
00194 
00195         return 0;
00196 }
00197 
00198 
00207 int SO3CameraGetDerivedDirection(mmachine m)
00208 {
00209 #ifdef SO3_DEBUG
00210         MMechostr(MSKDEBUG, "SO3CameraGetDerivedDirection\n");
00211 #endif
00212 
00213   int cam = MMget(m, 0);
00214         if(cam==NIL)
00215   { 
00216     MMset(m, 0, NIL);
00217     return 0;   
00218   }
00219 
00220   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00221   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00222   {
00223     MMset(m, 0, NIL);
00224     return 0;
00225   }
00226 
00227   SCamera* camera = static_cast<SCamera*>(node);
00228 
00229   // TODO in SNode or SCamera
00230   Ogre::Vector3 vecteur(camera->GetOgreCameraPointer()->getDerivedDirection());
00231         int tuple = MMmalloc(m, 3, TYPETAB);
00232         if(tuple==NIL)
00233   {
00234     MMset(m, 0, NIL);   
00235     return MERRMEM;     
00236   }
00237 
00238         MMstore(m, tuple, 0, FTOM((vecteur.x)));
00239         MMstore(m, tuple, 1, FTOM((vecteur.y)));
00240         MMstore(m, tuple, 2, FTOM((vecteur.z)));
00241   MMset(m, 0, PTOM(tuple));
00242 
00243         return 0;
00244 }
00245 
00246 
00255 int SO3CameraGetDerivedUp(mmachine m)
00256 {
00257 #ifdef SO3_DEBUG
00258         MMechostr(MSKDEBUG, "SO3CameraGetDerivedUp\n");
00259 #endif
00260 
00261   int cam = MMget(m, 0);
00262         if(cam==NIL)
00263   { 
00264     MMset(m, 0, NIL);           
00265     return 0;
00266   }
00267 
00268   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00269   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00270   {
00271     MMset(m, 0, NIL);
00272     return 0;
00273   }
00274 
00275   SCamera* camera = static_cast<SCamera*>(node);
00276 
00277   // TODO function in SNode or SCamera
00278   Ogre::Vector3 vecteur(camera->GetOgreCameraPointer()->getDerivedUp());
00279         int tuple = MMmalloc(m, 3, TYPETAB);
00280         if(tuple==NIL)
00281   {     
00282     MMset(m, 0, NIL);
00283     return MERRMEM;
00284   }
00285 
00286         MMstore(m, tuple, 0, FTOM((vecteur.x)));
00287         MMstore(m, tuple, 1, FTOM((vecteur.y)));
00288         MMstore(m, tuple, 2, FTOM((vecteur.z)));
00289   MMset(m, 0, PTOM(tuple));
00290 
00291         return 0;
00292 }
00293 
00294 
00304 int SO3CameraSetViewport(mmachine m)
00305 {
00306 #ifdef SO3_DEBUG
00307         MMechostr(MSKDEBUG, "SO3CameraSetViewport\n");
00308 #endif
00309 
00310   // secure method to get the scol object since the ptr can be valid in the scol var but no more in scol tape
00311         //int cam = OBJfindTM(m, MMpull(m), SO3OBJTYPE);
00312   int cam = MMpull(m);
00313   int vp = MMget(m, 0);
00314  
00315   if((vp==NIL)||(cam==NIL))
00316   {
00317     MMset(m, 0, NIL);   
00318     return 0;   
00319   }
00320 
00321   SViewPort* viewport = (SViewPort*) MMfetch(m, MTOP(vp), 0);
00322         if(viewport==NULL)      
00323   {
00324     MMechostr(MSKDEBUG,"vp is NULL \n");
00325     MMset(m, 0, NIL);
00326     return 0;   
00327   }
00328 
00329   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00330   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00331   {
00332     MMset(m, 0, NIL);
00333     return 0;
00334   }
00335 
00336   SCamera* camera = static_cast<SCamera*>(node);
00337   viewport->SetCamera(camera);
00338 
00339   MMset(m, 0, ITOM(1));
00340   return 0;
00341 }
00342 
00343 
00353 int SO3CameraSetFocalLenght(mmachine m)
00354 {
00355 #ifdef SO3_DEBUG
00356         MMechostr(MSKDEBUG, "SO3CameraSetFocalLenght\n");
00357 #endif
00358 
00359   int f = MMpull(m);
00360   int cam = MMget(m, 0);
00361   
00362   if((cam==NIL)||(f==NIL))
00363   { 
00364     MMset(m, 0, NIL);           
00365     return 0;
00366   }
00367   
00368   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00369   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00370   {
00371     MMset(m, 0, NIL);
00372     return 0;
00373   }
00374 
00375   SCamera* camera = static_cast<SCamera*>(node);
00376 
00377   if(MTOF(f)==0.0)
00378   {
00379     MMset(m, 0, NIL);   
00380     return 0;
00381   }
00382 
00383   // TODO in SCamera
00384   camera->GetOgreCameraPointer()->setFocalLength(MTOF(f));
00385 
00386   MMset(m, 0, ITOM(1));
00387 
00388         return 0;
00389 }
00390 
00391 
00400 int SO3CameraGetFocalLenght(mmachine m)
00401 {
00402 #ifdef SO3_DEBUG
00403         MMechostr(MSKDEBUG, "SO3CameraGetFocalLenght\n");
00404 #endif
00405 
00406   int cam = MMget(m, 0);
00407   if(cam==NIL)
00408   {
00409     MMset(m, 0, NIL);   
00410     return 0;   
00411   }
00412 
00413   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00414   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00415   {
00416     MMset(m, 0, NIL);
00417     return 0;
00418   }
00419 
00420   SCamera* camera = static_cast<SCamera*>(node);
00421 
00422   // TODO in SCamera
00423   float f = camera->GetOgreCameraPointer()->getFocalLength();
00424   MMset(m, 0, FTOM(f));
00425 
00426   return 0;
00427 }
00428 
00429 
00439 int SO3CameraSetFOVy(mmachine m)
00440 {
00441 #ifdef SO3_DEBUG
00442         MMechostr(MSKDEBUG, "SO3CameraSetFOVy\n");
00443 #endif
00444 
00445   int fovy = MMpull(m);
00446   int cam        = MMget(m, 0);
00447   if((cam==NIL)||(fovy==NIL))   
00448   {     
00449     MMset(m, 0, NIL);
00450     return 0;   
00451   }
00452 
00453   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00454   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00455   {
00456     MMset(m, 0, NIL);
00457     return 0;
00458   }
00459 
00460   SCamera* camera = static_cast<SCamera*>(node);
00461 
00462   // TODO in SCamera
00463   camera->GetOgreCameraPointer()->setFOVy(Ogre::Radian(MTOF(fovy)));
00464 
00465   MMset(m, 0, ITOM(1));
00466 
00467   return 0;
00468 }
00469 
00470 
00479 int SO3CameraGetFOVy(mmachine m)
00480 {
00481 #ifdef SO3_DEBUG
00482         MMechostr(MSKDEBUG, "SO3CameraGetFOVy\n");
00483 #endif
00484 
00485   int cam = MMget(m, 0);
00486   if(cam==NIL)
00487   {
00488     MMset(m, 0, NIL);
00489     return 0;
00490   }
00491 
00492   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00493   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00494   {
00495     MMset(m, 0, NIL);
00496     return 0;
00497   }
00498 
00499   SCamera* camera = static_cast<SCamera*>(node);
00500 
00501   // TODO in SCamera
00502   float fovy = camera->GetOgreCameraPointer()->getFOVy().valueRadians();
00503   MMset(m, 0, FTOM(fovy));
00504 
00505   return 0;
00506 }
00507 
00508 
00523 int SO3CameraSetPolygonMode(mmachine m)
00524 {
00525 #ifdef SO3_DEBUG
00526         MMechostr(MSKDEBUG, "SO3CameraSetPolygonMode\n");
00527 #endif
00528 
00529   int b = MTOI(MMpull(m));
00530   int cam = MMget(m, 0);
00531   if((cam==NIL) || (b==NIL))    
00532   {
00533     MMset(m, 0, NIL);   
00534     return 0;
00535   }
00536 
00537   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00538   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00539   {
00540     MMset(m, 0, NIL);
00541     return 0;
00542   }
00543 
00544   SCamera* camera = static_cast<SCamera*>(node);
00545 
00546   // TODO in SCamera
00547         if(b==SO3_POLY_POINTS)
00548     camera->GetOgreCameraPointer()->setPolygonMode(Ogre::PM_POINTS);
00549   else if(b==SO3_POLY_SOLID)
00550     camera->GetOgreCameraPointer()->setPolygonMode(Ogre::PM_SOLID);
00551   if(b==SO3_POLY_WIREFRAME)
00552     camera->GetOgreCameraPointer()->setPolygonMode(Ogre::PM_WIREFRAME);
00553 
00554   MMset(m, 0, ITOM(1));
00555         return 0;
00556 }
00557 
00558 
00572 int SO3CameraGetPolygonMode(mmachine m)
00573 {
00574 #ifdef SO3_DEBUG
00575         MMechostr(MSKDEBUG, "SO3CameraGetPolygonMode\n");
00576 #endif
00577 
00578   int cam = MMget(m, 0);
00579   if(cam==NIL)  
00580   {
00581     MMset(m, 0, NIL);   
00582     return 0;
00583   }
00584   
00585   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00586   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00587   {
00588     MMset(m, 0, NIL);
00589     return 0;
00590   }
00591 
00592   SCamera* camera = static_cast<SCamera*>(node);
00593 
00594   // TODO in SCamera
00595   if(camera->GetOgreCameraPointer()->getPolygonMode() == Ogre::PM_POINTS)
00596     MMset(m, 0, ITOM(SO3_POLY_POINTS));
00597   else if(camera->GetOgreCameraPointer()->getPolygonMode() == Ogre::PM_SOLID)
00598     MMset(m, 0, ITOM(SO3_POLY_SOLID));
00599   else if(camera->GetOgreCameraPointer()->getPolygonMode() == Ogre::PM_WIREFRAME)
00600     MMset(m, 0, ITOM(SO3_POLY_WIREFRAME));
00601   else
00602     MMset(m, 0, NIL);
00603 
00604   return 0;
00605 }
00606 
00607 
00621 int SO3CameraSetProjectionType(mmachine m)
00622 {
00623 #ifdef SO3_DEBUG
00624         MMechostr(MSKDEBUG, "SO3CameraSetProjectionType\n");
00625 #endif
00626 
00627   int b = MTOI(MMpull(m));
00628   int cam = MMget(m, 0); 
00629   if((cam==NIL) || (b==NIL))
00630   {
00631     MMset(m, 0, NIL);
00632     return 0;   
00633   }
00634  
00635   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00636   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00637   {
00638     MMset(m, 0, NIL);
00639     return 0;
00640   }
00641 
00642   SCamera* camera = static_cast<SCamera*>(node);
00643 
00644   // TODO in SCamera
00645         if(b==SO3_PROJECTION_PERSPECTIVE)
00646     camera->GetOgreCameraPointer()->setProjectionType(Ogre::PT_PERSPECTIVE);
00647   else if(b==SO3_PROJECTION_ORTHOGRAPHIC)
00648     camera->GetOgreCameraPointer()->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
00649 
00650   MMset(m, 0, ITOM(1));
00651         return 0;
00652 }
00653 
00654 
00667 int SO3CameraGetProjectionType(mmachine m)
00668 {
00669 #ifdef SO3_DEBUG
00670         MMechostr(MSKDEBUG, "SO3CameraGetProjectionType\n");
00671 #endif
00672 
00673   int cam = MMget(m, 0);
00674   if(cam==NIL)
00675   {
00676     MMset(m, 0, NIL);   
00677     return 0;
00678   }
00679 
00680   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00681   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00682   {
00683     MMset(m, 0, NIL);
00684     return 0;
00685   }
00686 
00687   SCamera* camera = static_cast<SCamera*>(node);
00688 
00689   // TODO in SCamera
00690   if(camera->GetOgreCameraPointer()->getProjectionType() == Ogre::PT_PERSPECTIVE)
00691     MMset(m, 0, ITOM(SO3_PROJECTION_PERSPECTIVE));
00692   else if(camera->GetOgreCameraPointer()->getProjectionType() == Ogre::PT_ORTHOGRAPHIC)
00693     MMset(m, 0, ITOM(SO3_PROJECTION_ORTHOGRAPHIC));
00694   else 
00695     MMset(m, 0, NIL);
00696 
00697   return 0;
00698 }
00699 
00700 
00711 int SO3CameraSetOrthoWindow(mmachine m)
00712 {
00713 #ifdef SO3_DEBUG
00714         MMechostr(MSKDEBUG, "SO3CameraSetOrthoWindow\n");
00715 #endif
00716 
00717   int width = MMpull(m);
00718   int height = MMpull(m);
00719   int cam = MMget(m, 0);
00720   if((cam==NIL)||(width==NIL)||(height==NIL))
00721   {
00722     MMset(m, 0, NIL);   
00723     return 0;   
00724   }
00725 
00726   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00727   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00728   {
00729     MMset(m, 0, NIL);
00730     return 0;
00731   }
00732 
00733   SCamera* camera = static_cast<SCamera*>(node);
00734 
00735   // TODO in SCamera
00736   camera->GetOgreCameraPointer()->setOrthoWindow(Ogre::Real(MTOF(width)), Ogre::Real(MTOF(height)));
00737 
00738   MMset(m, 0, ITOM(1));
00739 
00740   return 0;
00741 }
00742 
00743 
00752 int SO3CameraGetOrthoWindow(mmachine m)
00753 {
00754 #ifdef SO3_DEBUG
00755         MMechostr(MSKDEBUG, "SO3CameraGetOrthoWindow\n");
00756 #endif
00757 
00758   int cam = MMget(m, 0);
00759   if(cam==NIL)
00760   { 
00761     MMset(m, 0, NIL);
00762     return 0;   
00763   }
00764 
00765   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00766   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00767   {
00768     MMset(m, 0, NIL);
00769     return 0;
00770   }
00771 
00772   SCamera* camera = static_cast<SCamera*>(node);
00773 
00774   // TODO in SCamera
00775   float width = camera->GetOgreCameraPointer()->getOrthoWindowWidth();
00776   float height = camera->GetOgreCameraPointer()->getOrthoWindowHeight();
00777   int tuple = MMmalloc(m, 2, TYPETAB);
00778         if(tuple==NIL)
00779   {
00780     MMset(m, 0, NIL);   
00781     return MERRMEM;
00782   }
00783         
00784   MMstore(m, tuple, 0, FTOM(width));
00785         MMstore(m, tuple, 1, FTOM(height));
00786         MMset(m, 0, PTOM(tuple));
00787 
00788   return 0;
00789 }
00790 
00791 
00801 int SO3CameraSetNearClipDistance(mmachine m)
00802 {
00803 #ifdef SO3_DEBUG
00804         MMechostr(MSKDEBUG, "SO3CameraSetNearClipDistance\n");
00805 #endif
00806 
00807   int n = MMpull(m);
00808   int cam        = MMget(m, 0);
00809   if((cam==NIL)||(n==NIL))      
00810   {
00811     MMset(m, 0, NIL);
00812     return 0;
00813   }
00814 
00815   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00816   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00817   {
00818     MMset(m, 0, NIL);
00819     return 0;
00820   }
00821 
00822   SCamera* camera = static_cast<SCamera*>(node);
00823 
00824   if(MTOF(n)==0.0f)
00825   {     
00826     MMset(m, 0, NIL);
00827     return 0;   
00828   }
00829 
00830   camera->SetNearClipDistance(MTOF(n));
00831 
00832   MMset(m, 0, ITOM(1));
00833   return 0;
00834 }
00835 
00836 
00845 int SO3CameraGetNearClipDistance(mmachine m)
00846 {
00847 #ifdef SO3_DEBUG
00848         MMechostr(MSKDEBUG, "SO3CameraGetNearClipDistance\n");
00849 #endif
00850 
00851   int cam = MMget(m, 0);
00852   if(cam==NIL)
00853   { 
00854     MMset(m, 0, NIL);           
00855     return 0;
00856   }
00857 
00858   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00859   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00860   {
00861     MMset(m, 0, NIL);
00862     return 0;
00863   }
00864 
00865   SCamera* camera = static_cast<SCamera*>(node);
00866 
00867   MMset(m, 0, FTOM(camera->GetNearClipDistance()));
00868 
00869   return 0;
00870 }
00871 
00872 
00882 int SO3CameraSetFarClipDistance(mmachine m)
00883 {
00884 #ifdef SO3_DEBUG
00885         MMechostr(MSKDEBUG, "SO3CameraSetFarClipDistance\n");
00886 #endif
00887 
00888   int val = MMpull(m);
00889   int cam = MMget(m, 0);
00890   if((cam==NIL)||(val==NIL))    
00891   {     
00892     MMset(m, 0, NIL);
00893     return 0;
00894   }
00895 
00896   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00897   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00898   {
00899     MMset(m, 0, NIL);
00900     return 0;
00901   }
00902 
00903   SCamera* camera = static_cast<SCamera*>(node);
00904 
00905   camera->SetFarClipDistance(MTOF(val));
00906   MMset(m, 0, ITOM(1));
00907   return 0;
00908 }
00909 
00910 
00919 int SO3CameraGetFarClipDistance(mmachine m)
00920 {
00921 #ifdef SO3_DEBUG
00922         MMechostr(MSKDEBUG, "SO3CameraGetFarClipDistance\n");
00923 #endif
00924 
00925   int cam = MMget(m, 0);
00926   if(cam==NIL)
00927   {
00928     MMset(m, 0, NIL);           
00929     return 0;   
00930   }
00931 
00932   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00933   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00934   {
00935     MMset(m, 0, NIL);
00936     return 0;
00937   }
00938 
00939   SCamera* camera = static_cast<SCamera*>(node);
00940 
00941   MMset(m, 0, FTOM(camera->GetFarClipDistance()));
00942 
00943   return 0;
00944 }
00945 
00946 
00955 int SO3CameraGetViewport(mmachine m)
00956 {
00957         #ifdef SO3_DEBUG
00958         MMechostr(MSKDEBUG,"SO3CameraGetViewport\n");
00959         #endif
00960 
00961   int cam = MMget(m, 0);
00962   if(cam==NIL)
00963   { 
00964     MMset(m, 0, NIL);   
00965     return 0;
00966   }
00967 
00968   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
00969   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
00970   {
00971     MMset(m, 0, NIL);
00972     return 0;
00973   }
00974 
00975   SCamera* camera = static_cast<SCamera*>(node);
00976 
00977   SViewPort* viewport = camera->getCurrentViewPort();
00978   if(viewport==NULL)                            
00979   {     
00980     MMset(m, 0, NIL);   
00981     return 0;
00982   }
00983 
00984   int vp = OBJfindTH(m, SO3VPTYPE, (int)(viewport));
00985   if(vp!=NIL)
00986     vp = MMfetch(m, vp, OFFOBJMAG);
00987   
00988   MMset(m, 0, vp);
00989   return 0;
00990 }
00991 
00992 
01001 int SO3CameraGetNumRenderedFaces(mmachine m)
01002 {
01003 #ifdef SO3_DEBUG
01004         MMechostr(MSKDEBUG, "SO3CameraGetNumRenderedFaces\n");
01005 #endif
01006 
01007   int cam = MMget(m, 0); 
01008   if(cam==NIL)
01009   {
01010     MMset(m, 0, NIL);
01011     return 0;
01012   }
01013 
01014   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
01015   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
01016   {
01017     MMset(m, 0, NIL);
01018     return 0;
01019   }
01020 
01021   SCamera* camera = static_cast<SCamera*>(node);
01022 
01023   // TODO in SCamera
01024   int nb = camera->GetOgreCameraPointer()->_getNumRenderedFaces();
01025   MMset(m, 0, ITOM(nb));
01026 
01027   return 0;
01028 }
01029 
01030 
01039 int SO3CameraSetProjectionMatrix(mmachine m)
01040 {
01041 #ifdef SO3_DEBUG
01042         MMechostr(MSKDEBUG, "SO3CameraSetProjectionMatrix\n");
01043 #endif
01044 
01045   int imat = MMpull(m);
01046   int cam = MMget(m, 0); 
01047   if(cam==NIL)
01048   {
01049     MMset(m, 0, NIL);
01050     return 0;
01051   }
01052 
01053   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
01054   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
01055   {
01056     MMset(m, 0, NIL);
01057     return 0;
01058   }
01059 
01060   SCamera* camera = static_cast<SCamera*>(node);
01061   if (camera == 0)
01062   {
01063     MMset(m, 0, NIL);
01064     return 0;
01065   }
01066   
01067   if (imat != NIL)
01068   {
01069     int imat0 = MMfetch(m, MTOP(imat), 0);
01070     int imat1 = MMfetch(m, MTOP(imat), 1);
01071     int imat2 = MMfetch(m, MTOP(imat), 2);
01072     int imat3 = MMfetch(m, MTOP(imat), 3);
01073   
01074     Ogre::Matrix4 projmat(MTOF(MMfetch(m, MTOP(imat0), 0)), MTOF(MMfetch(m, MTOP(imat0), 1)), MTOF(MMfetch(m, MTOP(imat0), 2)), MTOF(MMfetch(m, MTOP(imat0), 3)),
01075                           MTOF(MMfetch(m, MTOP(imat1), 0)), MTOF(MMfetch(m, MTOP(imat1), 1)), MTOF(MMfetch(m, MTOP(imat1), 2)), MTOF(MMfetch(m, MTOP(imat1), 3)),
01076                           MTOF(MMfetch(m, MTOP(imat2), 0)), MTOF(MMfetch(m, MTOP(imat2), 1)), MTOF(MMfetch(m, MTOP(imat2), 2)), MTOF(MMfetch(m, MTOP(imat2), 3)),
01077                           MTOF(MMfetch(m, MTOP(imat3), 0)), MTOF(MMfetch(m, MTOP(imat3), 1)), MTOF(MMfetch(m, MTOP(imat3), 2)), MTOF(MMfetch(m, MTOP(imat3), 3)));
01078 
01079     try
01080     {
01081       camera->GetOgreCameraPointer()->setCustomProjectionMatrix(true, projmat);
01082     }
01083     catch(Ogre::Exception &e)
01084     {
01085       MMechostr(MSKDEBUG, "SO3CameraSetProjectionMatrix matrix error : %s\n", e.what());
01086     }
01087   }
01088   else
01089   {
01090     try
01091     {
01092       camera->GetOgreCameraPointer()->setCustomProjectionMatrix(false);
01093     }
01094     catch(Ogre::Exception &e)
01095     {
01096       MMechostr(MSKDEBUG, "SO3CameraSetProjectionMatrix matrix error : %s\n", e.what());
01097     }
01098   }
01099 
01100   MMset(m, 0, ITOM(1));
01101 
01102   return 0;
01103 }
01104 
01112 int SO3CameraGetProjectionMatrix(mmachine m)
01113 {
01114         #ifdef  _SCOL_DEBUG_
01115         MMechostr(MSKDEBUG, "SO3CameraGetProjectionMatrix\n");
01116         #endif
01117         
01118   int cam = MMget(m, 0); 
01119   if(cam==NIL)
01120   {
01121     MMset(m, 0, NIL);
01122     return 0;
01123   }
01124 
01125   SNode* node = (SNode*) MMfetch(m, MTOP(cam), 0);
01126   if (node->GetNodeType() != SNode::CAMERA_TYPE_ID)
01127   {
01128     MMset(m, 0, NIL);
01129     return 0;
01130   }
01131 
01132   SCamera* camera = static_cast<SCamera*>(node);
01133   if (camera == 0)
01134   {
01135     MMset(m, 0, NIL);
01136     return 0;
01137   }
01138 
01139   Ogre::Matrix4 proj_mat = camera->GetProjectionMatrix();
01140 
01141         int tupleMat = MMmalloc(m, 4, TYPETAB);
01142   if(tupleMat==NIL)                             
01143   {
01144     MMset(m, 0, NIL);
01145                 return 0;
01146   }
01147 
01148         int tupleMat0 = MMmalloc(m, 4, TYPETAB);
01149   if(tupleMat0==NIL)                            
01150   {
01151     MMset(m, 0, NIL);
01152                 return 0;
01153   }
01154 
01155         MMstore(m, tupleMat0, 0, FTOM(static_cast<float>(proj_mat[0][0])));
01156         MMstore(m, tupleMat0, 1, FTOM(static_cast<float>(proj_mat[0][1])));
01157         MMstore(m, tupleMat0, 2, FTOM(static_cast<float>(proj_mat[0][2])));
01158         MMstore(m, tupleMat0, 3, FTOM(static_cast<float>(proj_mat[0][3])));
01159         MMpush(m, PTOM(tupleMat0));
01160 
01161         int tupleMat1 = MMmalloc(m, 4, TYPETAB);
01162   if(tupleMat1==NIL)                            
01163   {
01164     MMset(m, 0, NIL);
01165                 return 0;
01166   }
01167 
01168         MMstore(m, tupleMat1, 0, FTOM(static_cast<float>(proj_mat[1][0])));
01169         MMstore(m, tupleMat1, 1, FTOM(static_cast<float>(proj_mat[1][1])));
01170         MMstore(m, tupleMat1, 2, FTOM(static_cast<float>(proj_mat[1][2])));
01171         MMstore(m, tupleMat1, 3, FTOM(static_cast<float>(proj_mat[1][3])));
01172         MMpush(m, PTOM(tupleMat1));
01173 
01174         int tupleMat2 = MMmalloc(m, 4, TYPETAB);
01175   if(tupleMat2==NIL)                            
01176   {
01177     MMset(m, 0, NIL);
01178                 return 0;
01179   }
01180 
01181         MMstore(m, tupleMat2, 0, FTOM(static_cast<float>(proj_mat[2][0])));
01182         MMstore(m, tupleMat2, 1, FTOM(static_cast<float>(proj_mat[2][1])));
01183         MMstore(m, tupleMat2, 2, FTOM(static_cast<float>(proj_mat[2][2])));
01184         MMstore(m, tupleMat2, 3, FTOM(static_cast<float>(proj_mat[2][3])));
01185         MMpush(m, PTOM(tupleMat2));
01186 
01187         int tupleMat3 = MMmalloc(m, 4, TYPETAB);
01188   if(tupleMat==NIL)                             
01189   {
01190     MMset(m, 0, NIL);
01191                 return 0;
01192   }
01193 
01194         MMstore(m, tupleMat3, 0, FTOM(static_cast<float>(proj_mat[3][0])));
01195         MMstore(m, tupleMat3, 1, FTOM(static_cast<float>(proj_mat[3][1])));
01196         MMstore(m, tupleMat3, 2, FTOM(static_cast<float>(proj_mat[3][2])));
01197         MMstore(m, tupleMat3, 3, FTOM(static_cast<float>(proj_mat[3][3])));
01198         MMpush(m, PTOM(tupleMat3));
01199 
01200         MMstore(m, tupleMat, 0, MMget(m, 3));
01201         MMstore(m, tupleMat, 1, MMget(m, 2));
01202         MMstore(m, tupleMat, 2, MMget(m, 1));
01203         MMstore(m, tupleMat, 3, MMget(m, 0));
01204 
01205   MMpull(m);
01206   MMpull(m);
01207   MMpull(m);
01208   MMpull(m);
01209   MMpush(m, PTOM(tupleMat));
01210 
01211         #ifdef  _SCOL_DEBUG_
01212                 MMechostr(MSKDEBUG, "ok\n");
01213         #endif
01214                 return 0;
01215 }
01216 
01220 #define NBCAMERAPKG 24
01221 
01222 
01226 char* CAMERAname[NBCAMERAPKG]= 
01227 {
01228         "SO3CameraCreate",
01229         "SO3CameraLookAt",
01230         "SO3CameraGetDirection",
01231         "SO3CameraGetDerivedDirection",
01232   "SO3CameraGetDerivedUp",
01233         "SO3CameraSetViewport",
01234         "SO3CameraSetFocalLenght",
01235         "SO3CameraGetFocalLenght",
01236         "SO3CameraSetFOVy",
01237         "SO3CameraGetFOVy",
01238   "SO3CameraSetPolygonMode",
01239   "SO3CameraGetPolygonMode",
01240         "SO3CameraSetNearClipDistance",
01241         "SO3CameraGetNearClipDistance",
01242         "SO3CameraSetFarClipDistance",
01243         "SO3CameraGetFarClipDistance",
01244         "SO3CameraGetViewport",
01245         "SO3CameraGetNumRenderedFaces",
01246   "SO3CameraSetProjectionType",
01247   "SO3CameraGetProjectionType",
01248   "SO3CameraSetOrthoWindow",
01249   "SO3CameraGetOrthoWindow",
01250   "SO3CameraSetProjectionMatrix",
01251   "SO3CameraGetProjectionMatrix"
01252 };
01253 
01254 
01258 int (*CAMERAFunc[NBCAMERAPKG])(mmachine m)=
01259 {
01260         SO3CameraCreate,
01261         SO3CameraLookAt,
01262         SO3CameraGetDirection,
01263         SO3CameraGetDerivedDirection,
01264   SO3CameraGetDerivedUp,
01265         SO3CameraSetViewport,
01266         SO3CameraSetFocalLenght,
01267         SO3CameraGetFocalLenght,
01268         SO3CameraSetFOVy,
01269         SO3CameraGetFOVy,
01270   SO3CameraSetPolygonMode,
01271   SO3CameraGetPolygonMode,
01272         SO3CameraSetNearClipDistance,
01273         SO3CameraGetNearClipDistance,
01274         SO3CameraSetFarClipDistance,
01275         SO3CameraGetFarClipDistance,
01276         SO3CameraGetViewport,
01277         SO3CameraGetNumRenderedFaces,
01278   SO3CameraSetProjectionType,
01279   SO3CameraGetProjectionType,
01280   SO3CameraSetOrthoWindow,
01281   SO3CameraGetOrthoWindow,
01282   SO3CameraSetProjectionMatrix,
01283   SO3CameraGetProjectionMatrix
01284 };
01285 
01286 
01290 int CAMERAnarg[NBCAMERAPKG]= 
01291 {
01292         2,                                                                                      //SO3CameraCreate
01293         2,                                                                                      //SO3CameraLookAt
01294         1,                                                                                      //SO3CameraGetDirection
01295         1,                                                                                      //SO3CameraGetDerivedDirection
01296   1,                      //SO3CameraGetDerivedUp
01297         2,                                                                                      //SO3CameraSetViewport
01298         2,                                                                                      //SO3CameraSetFocalLenght
01299         1,                                                                                      //SO3CameraGetFocalLenght
01300         2,                                                                                      //SO3CameraSetFOVy
01301         1,                                                                                      //SO3CameraGetFOVy
01302   2,                                                                                    //SO3CameraSetPolygonMode
01303   1,                                                                                    //SO3CameraGetPolygonMode
01304         2,                                                                                      //SO3CameraSetNearClipDistance
01305         1,                                                                                      //SO3CameraGetNearClipDistance
01306         2,                                                                                      //SO3CameraSetFarClipDistance
01307         1,                                                                                      //SO3CameraGetFarClipDistance
01308         1,                                                                                      //SO3CameraGetViewport
01309         1,                                                                                      //SO3CameraGetNumRenderedFaces
01310   2,                      //SO3CameraSetProjectionType
01311   1,                      //SO3CameraGetProjectionType
01312   3,                      //SO3CameraSetOrthoWindow
01313   1,                      //SO3CameraGetOrthoWindow
01314   2,                      //SO3CameraSetProjectionMatrix
01315   1,                      //SO3CameraGetProjectionMatrix
01316 };
01317 
01318 
01322 char* CAMERAType[NBCAMERAPKG]=
01323 {
01324         "fun [SO3_SCENE S] SO3_OBJECT",                                                                         //SO3CameraCreate
01325         "fun [SO3_OBJECT [F F F]] I",                                                                                   //SO3CameraLookAt
01326         "fun [SO3_OBJECT] [F F F]",                                                                                             //SO3CameraGetDirection
01327         "fun [SO3_OBJECT] [F F F]",                                                                                             //SO3CameraGetDerivedDirection
01328   "fun [SO3_OBJECT] [F F F]",                                                     //SO3CameraDerivedUp
01329         "fun [SO3_VIEWPORT SO3_OBJECT] I",                                                              //SO3CameraSetViewport
01330         "fun [SO3_OBJECT F] I",                                                                                 //SO3CameraSetFocalLenght
01331         "fun [SO3_OBJECT] F",                                                                                           //SO3CameraGetFocalLenght
01332         "fun [SO3_OBJECT F] I",                                                                                 //SO3CameraSetFOVy
01333         "fun [SO3_OBJECT] F",                                                                                           //SO3CameraGetFOVy
01334   "fun [SO3_OBJECT I] I",                                                                                       //SO3CameraSetPolygonMode
01335   "fun [SO3_OBJECT] I",                                                                                         //SO3CameraGetPolygonMode
01336         "fun [SO3_OBJECT F] I",                                                                                 //SO3CameraSetNearClipDistance
01337         "fun [SO3_OBJECT] F",                                                                                           //SO3CameraGetNearClipDistance
01338         "fun [SO3_OBJECT F] I",                                                                                 //SO3CameraSetFarClipDistance
01339         "fun [SO3_OBJECT] F",                                                                                           //SO3CameraGetFarClipDistance
01340         "fun [SO3_OBJECT] SO3_VIEWPORT",                                                                  //SO3CameraGetViewport
01341         "fun [SO3_OBJECT] I",                                                                                                   //SO3CameraGetNumRenderedFaces
01342   "fun [SO3_OBJECT I] I",                                                         //SO3CameraSetProjectionType
01343   "fun [SO3_OBJECT] I",                                                           //SO3CameraGetProjectionType
01344   "fun [SO3_OBJECT F F] I",                                                       //SO3CameraSetOrthoWindow
01345   "fun [SO3_OBJECT] [F F]",                                                       //SO3CameraGetOrthoWindow
01346   "fun [SO3_OBJECT [[F F F F] [F F F F] [F F F F] [F F F F]]] I",                 //SO3CameraSetProjectionMatrix
01347   "fun [SO3_OBJECT] [[F F F F] [F F F F] [F F F F] [F F F F]]"                    //SO3CameraGetProjectionMatrix
01348 };
01349 
01350 
01356 int SCOLloadCamera(mmachine m,cbmachine w)
01357 {       
01358         return PKhardpak(m, "Camera", NBCAMERAPKG, CAMERAname, CAMERAFunc, CAMERAnarg, CAMERAType);
01359 }
01360 
01361 
01366 int SCOLfreeCamera()
01367 {
01368         return 0;
01369 }