00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00036
00037 #include "SO3SCOL.h"
00038
00039
00040 #include "../SO3Animation/SO3Anim.h"
00041 #include "../SO3Animation/SO3AnimTrack.h"
00042 #include "../SO3Animation/SO3VertexAnimation.h"
00043 #include "../SO3Animation/SO3SequenceAnimation.h"
00044
00045
00046 #include "../SO3Material/SO3Compositor.h"
00047 #include "../SO3Material/SO3Material.h"
00048 #include "../SO3Material/SO3Texture.h"
00049
00050
00051 #include "../SO3Renderer/SO3Root.h"
00052 #include "../SO3Renderer/SO3Viewport.h"
00053 #include "../SO3Renderer/SO3Window.h"
00054
00055
00056 #include "../SO3SceneGraph/SO3Bone.h"
00057 #include "../SO3SceneGraph/SO3Entity.h"
00058 #include "../SO3SceneGraph/SO3Scene.h"
00059 #include "../SO3SceneGraph/SO3Skeleton.h"
00060
00062 extern int SCENE_PRE_RENDER_EVENT;
00063 extern int SCENE_POST_RENDER_EVENT;
00064
00065 extern SRoot * scolRoot;
00066
00078 int SO3SceneLoadEntity(mmachine m)
00079 {
00080 #ifdef SO3_DEBUG
00081 MMechostr(MSKDEBUG,"SO3SceneLoadEntity\n");
00082 #endif
00083
00084 int p = MMpull(m);
00085 int name = MMpull(m);
00086 int grpname = MMpull(m);
00087 int s = MMpull(m);
00088
00089 if((p==NIL)||(s==NIL)||(name==NIL))
00090 {
00091 MMpush(m, NIL);
00092 return 0;
00093 }
00094
00095 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00096 if(scene==NULL)
00097 {
00098 MMpush(m, NIL);
00099 return 0;
00100 }
00101
00102 std::string tmpEntityName = MMstartstr(m, MTOP(name));
00103 std::string tmpMeshName = MMstartstr(m, MTOP(p));
00104
00105 for(unsigned int i=0; i<tmpMeshName.length(); i++)
00106 {
00107 if(tmpMeshName.substr(i,1) == "\\")
00108 tmpMeshName.replace(i,1,"/");
00109 }
00110
00111 std::string ressouceGroup;
00112 if (grpname == NIL)
00113 ressouceGroup = "General";
00114 else
00115 ressouceGroup = MMstartstr(m, MTOP(grpname));
00116
00117 SEntity* newEntity = 0;
00118
00119 try
00120 {
00121 newEntity = scene->CreateEntity(ressouceGroup, tmpEntityName, tmpMeshName);
00122
00123
00124 SAnimMap animationsListCopy = newEntity->GetAnimations();
00125 SAnimMap::iterator iAnimation = animationsListCopy.begin();
00126 while(iAnimation != animationsListCopy.end())
00127 {
00128 SAnim* newAnimation = iAnimation->second;
00129 assert(newAnimation != 0);
00130 createAnim(m, newAnimation, newEntity);
00131
00132 MMpull(m);
00133
00134 SAnimTrackList animationsTracksListCopy = newAnimation->GetAnimationsTracks();
00135 SAnimTrackList::iterator iAnimationTrack = animationsTracksListCopy.begin();
00136 while(iAnimationTrack != animationsTracksListCopy.end())
00137 {
00138 SAnimTrack* newAnimationTrack = (*iAnimationTrack);
00139 assert(newAnimationTrack != 0);
00140 createAnimTrack(m, newAnimationTrack, newAnimation);
00141
00142
00143 MMpull(m);
00144
00145 iAnimationTrack++;
00146 }
00147 iAnimation++;
00148 }
00149 }
00150 catch(Ogre::Exception &e)
00151 {
00152 MMechostr(MSKDEBUG,"An exception has occurred: %s\n", e.what());
00153 MMpush(m, NIL);
00154 return 0;
00155 }
00156
00157 return createObject(m, newEntity, scene);
00158 }
00159
00170 int SO3SceneUnloadResource(mmachine m)
00171 {
00172 #ifdef SO3_DEBUG
00173 MMechostr(MSKDEBUG, "SO3SceneUnloadResource\n");
00174 #endif
00175
00176 int type = MTOI(MMpull(m));
00177 int p = MMpull(m);
00178 int s = MMget(m, 0);
00179
00180 if((p==NIL)||(s==NIL))
00181 {
00182 MMset(m, 0, NIL);
00183 return 0;
00184 }
00185
00186 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00187 if(scene==NULL)
00188 {
00189 MMset(m, 0, NIL);
00190 return 0;
00191 }
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258 MMset(m, 0, 1);
00259 return 0;
00260 }
00261
00262
00283 int SO3SceneLoadResource(mmachine m)
00284 {
00285 #ifdef SO3_DEBUG
00286 MMechostr(MSKDEBUG,"SO3SceneLoadResource\n");
00287 #endif
00288
00289 int type = MTOI(MMpull(m));
00290 int p = MMpull(m);
00291 int group = MMpull(m);
00292 int s = MMpull(m);
00293
00294 if((p==NIL)||(s==NIL))
00295 {
00296 MMpush(m, NIL);
00297 return 0;
00298 }
00299
00300 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00301 if(scene==NULL)
00302 {
00303 MMpush(m, NIL);
00304 return 0;
00305 }
00306
00307 string pathStd = MMstartstr(m, MTOP(p));
00308 for(unsigned int i=0; i<pathStd.length(); i++)
00309 {
00310 if(pathStd.substr(i,1) == "\\")
00311 pathStd.replace(i,1,"/");
00312 }
00313
00314 const char* groupResource;
00315 if(group == NIL)
00316 groupResource = "General";
00317 else
00318 groupResource = MMstartstr(m, MTOP(group));
00319
00320
00321
00322 try
00323 {
00324 Ogre::ResourcePtr res;
00325 if(type == SO3_RESOURCE_MESH)
00326 {
00327 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, true);
00328 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "Mesh", groupResource);
00329 scene->O3MeshManager->parseScript(ds, groupResource);
00330 ds->close();
00331 }
00332 else if(type == SO3_RESOURCE_MATERIAL)
00333 {
00334 MMechostr(MSKDEBUG,"Loading Material Script resources \n");
00335 try
00336 {
00337 Ogre::ResourceGroupManager::getSingleton().createResourceGroup("tmpResouceGroup", false);
00338 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, "tmpResouceGroup", true);
00339 scene->O3MaterialManager->parseScript(ds, "tmpResouceGroup");
00340 ds->close();
00341 }
00342 catch(Ogre::Exception &e)
00343 {
00344 Ogre::ResourceGroupManager::getSingleton().clearResourceGroup("tmpResouceGroup");
00345 Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup("tmpResouceGroup");
00346 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
00347 MMpush(m, NIL);
00348 return 0;
00349 }
00350
00351 std::vector<string> matArray;
00352 Ogre::MaterialManager::ResourceMapIterator it = scene->O3MaterialManager->getResourceIterator();
00353 while(it.hasMoreElements())
00354 {
00355 Ogre::MaterialPtr mat = static_cast<Ogre::MaterialPtr>(it.getNext());
00356 std::string matFile = mat->getOrigin();
00357 if(!strcmp(matFile.c_str(), pathStd.c_str()))
00358 {
00359 SMaterial* material = scene->GetMaterial(groupResource, mat->getName().c_str());
00360 if(material == NULL)
00361 {
00362 matArray.push_back(mat->getName());
00363 }
00364 }
00365 }
00366
00367 Ogre::ResourceGroupManager::getSingleton().clearResourceGroup("tmpResouceGroup");
00368 Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup("tmpResouceGroup");
00369 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, true);
00370 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "Material", groupResource);
00371 scene->O3MaterialManager->parseScript(ds, groupResource);
00372 ds->close();
00373
00374 std::vector<string>::iterator iMatArray = matArray.begin();
00375 while (iMatArray != matArray.end())
00376 {
00377 scene->CreateMaterial(groupResource, iMatArray->c_str());
00378
00379
00380
00381
00382
00383 iMatArray++;
00384 }
00385
00386 }
00387 else if(type == SO3_RESOURCE_COMPOSITOR)
00388 {
00389 try
00390 {
00391 Ogre::ResourceGroupManager::getSingleton().createResourceGroup("tmpResouceGroup", false);
00392 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, "tmpResouceGroup", true);
00393 Ogre::CompositorManager::getSingleton().parseScript(ds, "tmpResouceGroup");
00394 ds->close();
00395 }
00396 catch(Ogre::Exception &e)
00397 {
00398 Ogre::ResourceGroupManager::getSingleton().clearResourceGroup("tmpResouceGroup");
00399 Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup("tmpResouceGroup");
00400 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
00401 MMpush(m, NIL);
00402 return 0;
00403 }
00404
00405 Ogre::ResourceGroupManager::getSingleton().clearResourceGroup("tmpResouceGroup");
00406 Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup("tmpResouceGroup");
00407 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, false);
00408 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "Material", groupResource);
00409 Ogre::CompositorManager::getSingleton().parseScript(ds, groupResource);
00410 ds->close();
00411 }
00412 else if(type == SO3_RESOURCE_PARTICLE_SYSTEM)
00413 {
00414 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, true);
00415 Ogre::ParticleSystemManager::getSingleton().parseScript(ds,groupResource);
00416 ds->close();
00417 Ogre::ParticleSystemManager::ParticleSystemTemplateIterator it = scene->O3ParticleSystemManager->getTemplateIterator();
00419
00420
00421
00422
00423
00424 }
00425 else if(type == SO3_RESOURCE_TEXTURE)
00426 {
00427
00428 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "Texture", groupResource);
00429 }
00430 else if(type == SO3_RESOURCE_SKELETON)
00431 {
00432 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, true);
00433 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "Skeleton", groupResource);
00434 scene->O3SkeletonManager->parseScript(ds, groupResource);
00435 ds->close();
00436 }
00437 else if(type == SO3_RESOURCE_GPUPROGRAM)
00438 {
00439 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, true);
00440 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "GpuProgram", groupResource);
00441 scene->O3MaterialManager->parseScript(ds, groupResource);
00442 }
00443 else if(type == SO3_RESOURCE_HIGHLEVELGPUPROGRAM)
00444 {
00445 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd, groupResource, true);
00446 Ogre::ResourceGroupManager::getSingleton().declareResource(pathStd, "HighLevelGpuProgram", groupResource);
00447 }
00448 MMpush(m, ITOM(1));
00449 return 0;
00450 }
00451 catch(Ogre::Exception &e)
00452 {
00453 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
00454 MMpush(m, NIL);
00455 return 0;
00456 }
00457 }
00458
00459
00470 int SO3SceneCloneAnimation(mmachine m)
00471 {
00472 #ifdef SO3_DEBUG
00473 MMechostr(MSKDEBUG,"SO3SceneCloneAnimation\n");
00474 #endif
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524 return 0;
00525 }
00526
00527
00539 int SO3SceneCloneAnimTrack(mmachine m)
00540 {
00541 #ifdef SO3_DEBUG
00542 MMechostr(MSKDEBUG,"SO3SceneCloneAnimTrack\n");
00543 #endif
00544 MMechostr(MSKRUNTIME, "DEPRECATED FUNCTION Call: SO3SceneCloneAnimTrack\n");
00545
00546 int at = MMpull(m);
00547 int anim = MMpull(m);
00548 int n = MMpull(m);
00549 int s = MMget(m,0);
00550
00551 MMset(m, 0, NIL);
00552 return 0;
00553 }
00554
00555
00567
00568 int SO3SceneLoadResourceMaterial(mmachine m)
00569 {
00570 #ifdef SO3_DEBUG
00571 MMechostr(MSKDEBUG,"SO3SceneLoadResourceMaterial\n");
00572 #endif
00573
00574 int p = MMpull(m);
00575 int group = MMpull(m);
00576 int s = MMget(m, 0);
00577
00578 if((p==NIL)||(s==NIL))
00579 {
00580 MMset(m,0,NIL);
00581 return 0;
00582 }
00583
00584 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00585 if(scene==NULL)
00586 {
00587 MMset(m, 0, NIL);
00588 return 0;
00589 }
00590
00591 string pathStd = MMstartstr(m, MTOP(p));
00592 string::size_type pos = pathStd.rfind("/");
00593 string resourceLocation = pathStd.substr(0,pos+1);
00594 string resource = pathStd.substr(pos+1,pathStd.length()-1);
00595 const char* groupResource;
00596 if(group == NIL)
00597 groupResource = "General";
00598 else
00599 groupResource = MMstartstr(m,MTOP(group));
00600 try
00601 {
00602 Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourceLocation,"FileSystem",groupResource);
00603 Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(pathStd,groupResource,true);
00604 scene->O3MaterialManager->parseScript(ds,groupResource);
00605 MMset(m, 0, ITOM(1));
00606 return 0;
00607 }
00608 catch(Ogre::Exception &e)
00609 {
00610 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
00611 MMset(m,0, NIL);
00612 return 0;
00613 }
00614 }
00615
00616
00626 int SO3SceneCreateAnimationSequence(mmachine m)
00627 {
00628 #ifdef SO3_DEBUG
00629 MMechostr(MSKDEBUG, "SO3SceneCreateAnimationSequence\n");
00630 #endif
00631
00632 int name = MMpull(m);
00633 int s = MMpull(m);
00634 if((name==NIL)||(s==NIL))
00635 {
00636 MMpush(m, NIL);
00637 return 0;
00638 }
00639
00640 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00641 if(scene==NULL)
00642 {
00643 MMpush(m, NIL);
00644 return 0;
00645 }
00646
00647 try
00648 {
00649 std::string animationName(MMstartstr(m, MTOP(name)));
00650 SAnim* animation = scene->CreateAnimationSequence(animationName);
00651 MMpush(m, scene->channel);
00652
00653 int a = MMmalloc(m, 1, TYPETAB);
00654 if(a==NIL)
00655 return MERRMEM;
00656
00657 MMstore(m, a, 0, (int)animation);
00658 MMpush(m, PTOM(a));
00659 return OBJcreate(m, SO3ANIM, (int)animation, SO3SCENETYPE, (int)scene);
00660
00661 }
00662 catch(Ogre::Exception &e)
00663 {
00664 MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
00665 MMpush(m, NIL);
00666 return 0;
00667 }
00668 }
00669
00670
00680 int SO3SceneCreate(mmachine m)
00681 {
00682 #ifdef SO3_DEBUG
00683 MMechostr(MSKDEBUG,"SO3SceneCreate\n");
00684 #endif
00685
00686 int name = MMpull(m);
00687 int channel = MMget(m, 0);
00688
00689
00690 if (name==NIL||channel == NIL)
00691 {
00692 MMset(m, 0, NIL);
00693 return 0;
00694 }
00695
00696
00697 const char* sceneName = MMstartstr(m, MTOP(name));
00698 SScene* newScene = scolRoot->CreateScene(sceneName, channel);
00699
00700
00701 int s = MMmalloc(m, 1, TYPETAB);
00702 if(s==NIL)
00703 return MERRMEM;
00704
00705
00706 MMstore(m, s, 0, (int)newScene);
00707 MMpush(m, PTOM(s));
00708
00709
00710 int scolSceneCreationReturn = OBJcreate(m, SO3SCENETYPE, (int)newScene, -1, -1);
00711
00712
00713 SNode* rootNode = newScene->GetRootNode();
00714
00715
00716 int scolRootNode = MMmalloc(m, 1, TYPETAB);
00717 if (scolRootNode==NIL)
00718 return MERRMEM;
00719
00720
00721 MMpush(m, channel);
00722 MMstore(m, scolRootNode, 0, (int)rootNode);
00723 MMpush(m, PTOM(scolRootNode));
00724
00725
00726 OBJcreate(m, SO3OBJTYPE, (int)rootNode, SO3SCENETYPE, (int)newScene);
00727
00728
00729 MMpull(m);
00730 return scolSceneCreationReturn;
00731 }
00732
00733
00742 int SO3SceneDelete(mmachine m)
00743 {
00744 #ifdef SO3_DEBUG
00745 MMechostr(MSKDEBUG,"SO3SceneDelete\n");
00746 #endif
00747
00748 int s = MMget(m, 0);
00749 if(s == NIL)
00750 {
00751 MMset(m, 0, NIL);
00752 return 0;
00753 }
00754
00755
00756 OBJdelTM(m, SO3SCENETYPE, s);
00757 MMset(m, 0, ITOM(1));
00758 return 0;
00759 }
00760
00761
00770 int SO3SceneClear(mmachine m)
00771 {
00772 #ifdef SO3_DEBUG
00773 MMechostr(MSKDEBUG,"SO3SceneClear\n");
00774 #endif
00775
00776 int s = MMget(m, 0);
00777 if(s==NIL)
00778 {
00779 MMset(m, 0, NIL);
00780 return 0;
00781 }
00782
00783 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00784 if(scene==NULL)
00785 {
00786 MMset(m, 0, NIL);
00787 return 0;
00788 }
00789
00790
00791 const SWindowMap windowList = scolRoot->GetRenderWindowList();
00792 SWindowMap::const_iterator iWindowList = windowList.begin();
00793 while (iWindowList != windowList.end())
00794 {
00795 SWindow* curWin = iWindowList->second;
00796
00797
00798 if(curWin->GetStereoMode() != SWindow::SO3_NONE_STEREO)
00799 curWin->SetStereoMode(SWindow::SO3_NONE_STEREO, 0, 0);
00800
00801
00802 const SViewPortList sviewportList = curWin->GetViewportList();
00803 SViewPortList::const_iterator iViewportList = sviewportList.begin();
00804 while (iViewportList != sviewportList.end())
00805 {
00806 iViewportList->second->ClearCompositors();
00807 iViewportList++;
00808 }
00809
00810 iWindowList++;
00811 }
00812
00813 const SGroupMaterialMap groupmatmap = scene->listOfMaterial;
00814 SGroupMaterialMap::const_iterator iGroupMaterialList = groupmatmap.begin();
00815 while (iGroupMaterialList != groupmatmap.end())
00816 {
00817 const SMaterialMap matmap = *(const_cast <const SMaterialMap*> (iGroupMaterialList->second));
00818 SMaterialMap::const_iterator iMaterialList = matmap.begin();
00819 while (iMaterialList != matmap.end())
00820 {
00821 SMaterial* tempMaterial = iMaterialList->second;
00822 int mat = OBJfindTH(m, SO3MATERIAL, (int)(tempMaterial));
00823
00824 if(mat!=NIL)
00825 mat = MMfetch(m,mat,OFFOBJMAG);
00826
00827 OBJdelTM(m, SO3MATERIAL, mat);
00828 iMaterialList++;
00829 }
00830 iGroupMaterialList++;
00831 }
00832
00833 const SGroupTextureMap grouptexmap = scene->listOfTexture;
00834 SGroupTextureMap::const_iterator iGroupTextureList = grouptexmap.begin();
00835 while (iGroupTextureList != grouptexmap.end())
00836 {
00837 const STextureMap texmap = *(const_cast <const STextureMap*> (iGroupTextureList->second));
00838 STextureMap::const_iterator iTextureList = texmap.begin();
00839 while (iTextureList != texmap.end())
00840 {
00841 int tx = OBJfindTH(m, SO3TEXTURE, (int)(iTextureList->second));
00842
00843 if(tx!=NIL)
00844 tx = MMfetch(m,tx,OFFOBJMAG);
00845
00846 OBJdelTM(m,SO3TEXTURE,tx);
00847 iTextureList++;
00848 }
00849 iGroupTextureList++;
00850 }
00851
00852 const SMaterialIDMap physicMatIdList = scene->GetPhysicsWorld()->listOfMaterialID;
00853 SMaterialIDMap::const_iterator iMaterialIDList = physicMatIdList.begin();
00854 while (iMaterialIDList != physicMatIdList.end())
00855 {
00856 int matID = OBJfindTH(m, SO3PHYSICSMATERIALTYPE, (int)(iMaterialIDList->second));
00857
00858 if(matID!=NIL)
00859 matID = MMfetch(m,matID,OFFOBJMAG);
00860
00861 OBJdelTM(m,SO3PHYSICSMATERIALTYPE,matID);
00862 iMaterialIDList++;
00863 }
00864
00865
00866 const SAnimMap seqAnimCopy = scene->GetAnimations();
00867 SAnimMap::const_iterator iSeqAnim = seqAnimCopy.begin();
00868 while (iSeqAnim != seqAnimCopy.end())
00869 {
00870 int n = OBJfindTH(m, SO3ANIM, (int)(iSeqAnim->second));
00871
00872 if(n!=NIL)
00873 n = MMfetch(m,n,OFFOBJMAG);
00874
00875 OBJdelTM(m,SO3ANIM,n);
00876 iSeqAnim++;
00877 }
00878
00879 const SNodeMap nodeListCopy = scene->GetNodeList();
00880 SNodeMap::const_iterator iNodeList = nodeListCopy.begin();
00881 while (iNodeList != nodeListCopy.end())
00882 {
00883 int n = OBJfindTH(m, SO3OBJTYPE, (int)(iNodeList->second));
00884
00885 if(n!=NIL)
00886 n = MMfetch(m,n,OFFOBJMAG);
00887
00888 OBJdelTM(m,SO3OBJTYPE,n);
00889 iNodeList++;
00890 }
00891
00892 scene->listOfMaterial.clear();
00893 scene->listOfTexture.clear();
00894 scene->GetPhysicsWorld()->listOfMaterialID.clear();
00895 scene->GetPhysicsWorld()->listOfPhysicsMaterialPair.clear();
00896
00897 scene->clearOgreScene();
00898 MMset(m,0,1);
00899 return 0;
00900 }
00901
00902
00912 int SO3WorldSetFPS(mmachine m)
00913 {
00914 #ifdef SO3_DEBUG
00915 MMechostr(MSKDEBUG, "SO3WorldSetFPS\n");
00916 #endif
00917
00918 int fps = MTOI(MMpull(m));
00919 int s = MMget(m, 0);
00920 if(s==NIL)
00921 {
00922 MMset(m, 0, NIL);
00923 return 0;
00924 }
00925
00926 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00927 if(scene==NULL)
00928 {
00929 MMset(m, 0, NIL);
00930 return 0;
00931 }
00932
00933 try
00934 {
00935 if(fps > 0)
00936 scene->GetPhysicsWorld()->SetPhysicFPS(fps);
00937
00938 MMset(m,0,1);
00939 return 0;
00940 }
00941 catch(Ogre::Exception &e)
00942 {
00943 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
00944 MMset(m,0,0);
00945 return 0;
00946 }
00947 }
00948
00949
00958 int SO3WorldSetSize(mmachine m)
00959 {
00960 #ifdef SO3_DEBUG
00961 MMechostr(MSKDEBUG,"SO3WorldSetSize\n");
00962 #endif
00963
00964 int sizeMax = MTOP(MMpull(m));
00965 int sizeMin = MTOP(MMpull(m));
00966 int s = MMget(m,0);
00967 if(s==NIL)
00968 {
00969 MMset(m,0,NIL);
00970 return 0;
00971 }
00972 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
00973 if(scene==NULL)
00974 {
00975 MMset(m,0,NIL);
00976 return 0;
00977 }
00978 try
00979 {
00980 Ogre::Vector3 vecteurMin;
00981 vecteurMin.x = MTOF(MMfetch(m,sizeMin,0));
00982 vecteurMin.y = MTOF(MMfetch(m,sizeMin,1));
00983 vecteurMin.z = MTOF(MMfetch(m,sizeMin,2));
00984
00985 Ogre::Vector3 vecteurMax;
00986 vecteurMax.x = MTOF(MMfetch(m,sizeMax,0));
00987 vecteurMax.y = MTOF(MMfetch(m,sizeMax,1));
00988 vecteurMax.z = MTOF(MMfetch(m,sizeMax,2));
00989 scene->GetPhysicsWorld()->SetPhysicWorldSize(vecteurMin, vecteurMax);
00990
00991 return 0;
00992 }
00993 catch(Ogre::Exception &e)
00994 {
00995 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
00996 MMset(m,0,0);
00997 return 0;
00998 }
00999 }
01000
01001
01016 int SO3SceneSetSkyBox(mmachine m)
01017 {
01018 #if SO3_DEBUG == 1
01019 MMechostr(MSKDEBUG,"SO3SceneSetSkyBox\n");
01020 #endif
01021
01022 int drawFirst = MTOI(MMpull(m));
01023 int booleen = MTOI(MMpull(m));
01024 int group = MMpull(m);
01025 int orient = MTOP(MMpull(m));
01026 float dist = MTOF(MMpull(m));
01027 int mat = MMpull(m);
01028 int s = MMget(m,0);
01029 if((s==NIL) || (mat==NIL))
01030 {
01031 MMset(m,0,NIL);
01032 return 0;
01033 }
01034 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01035 if(scene==NULL)
01036 {
01037 MMset(m,0,NIL);
01038 return 0;
01039 }
01040 SMaterial * material = (SMaterial*) MMfetch(m,MTOP(mat),0);
01041 if(material==NULL)
01042 {
01043 MMechostr(MSKDEBUG,"material==NULL\n");
01044 MMset(m,0,NIL);
01045 return 0;
01046 }
01047
01048 std::string groupResource("General");
01049
01050
01051
01052
01053
01054
01055
01056 Ogre::Quaternion quat;
01057 if(orient == NIL)
01058 quat = Ogre::Quaternion::IDENTITY;
01059 else
01060 {
01061 quat.x = MTOF(MMfetch(m,orient,0));
01062 quat.y = MTOF(MMfetch(m,orient,1));
01063 quat.z = MTOF(MMfetch(m,orient,2));
01064 quat.w = MTOF(MMfetch(m,orient,3));
01065 }
01066 try
01067 {
01068 if(!material->getOgreMaterialPointer().isNull())
01069 {
01070
01071 if(!scene->skyBoxMat.isNull())
01072 {
01073 scene->O3MaterialManager->remove(scene->skyBoxMat->getName());
01074 scene->O3MaterialManager->unload(scene->skyBoxMat->getName());
01075 }
01076
01077
01078 Ogre::MaterialPtr mCurrentMaterialPointer = material->getOgreMaterialPointer()->clone("mSkyBoxMaterial_" + material->getOgreMaterialPointer()->getName(), true, groupResource);
01079
01080
01081 if(booleen == 0 && drawFirst == 0)
01082 {
01083 scene->O3SceneManager->setSkyBox(false,mCurrentMaterialPointer->getName(),dist,false,quat,groupResource);
01084 scene->skyBoxDrawFirst = false;
01085 }
01086 else if(booleen == 0 && drawFirst != 0)
01087 {
01088 scene->O3SceneManager->setSkyBox(false,mCurrentMaterialPointer->getName(),dist,true,quat,groupResource);
01089 scene->skyBoxDrawFirst = true;
01090 }
01091 else if(booleen != 0 && drawFirst == 0)
01092 {
01093 scene->O3SceneManager->setSkyBox(true,mCurrentMaterialPointer->getName(),dist,false,quat,groupResource);
01094 scene->skyBoxDrawFirst = false;
01095 }
01096 else
01097 {
01098 scene->O3SceneManager->setSkyBox(true,mCurrentMaterialPointer->getName(),dist,true,quat,groupResource);
01099 scene->skyBoxDrawFirst = true;
01100 }
01101 scene->hasSkyBox = true;
01102 scene->skyBoxMat = mCurrentMaterialPointer;
01103 }
01104 MMset(m,0,1);
01105 return 0;
01106 }
01107 catch(Ogre::Exception &e)
01108 {
01109 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01110 MMset(m,0,0);
01111 return 0;
01112 }
01113 }
01114
01115
01125 int SO3SceneSetSkyBoxEnable(mmachine m)
01126 {
01127 #if SO3_DEBUG == 1
01128 MMechostr(MSKDEBUG,"SO3SceneSetSkyBoxEnable\n");
01129 #endif
01130
01131 int booleen = MTOI(MMpull(m));
01132 int s = MMget(m,0);
01133 if((s==NIL) || (booleen==NIL))
01134 {
01135 MMset(m,0,NIL);
01136 return 0;
01137 }
01138 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01139 if(scene==NULL)
01140 {
01141 MMset(m,0,NIL);
01142 return 0;
01143 }
01144 if(scene->skyBoxMat.isNull())
01145 {
01146 MMset(m,0,NIL);
01147 return 0;
01148 }
01149 if(scene->O3MaterialManager->getByName(scene->skyBoxMat->getName()).isNull())
01150 {
01151 MMset(m,0,NIL);
01152 return 0;
01153 }
01154 try
01155 {
01156 if(scene->hasSkyBox)
01157 {
01158 if(scene->O3SceneManager->getSkyBoxNode() != 0)
01159 {
01160 if(booleen == 0)
01161 {
01162 scene->O3SceneManager->getSkyBoxNode()->setVisible(false);
01163 scene->O3SceneManager->setSkyBox(false,"");
01164 if(!scene->skyBoxMat.isNull())
01165 {
01166 scene->O3MaterialManager->remove(scene->skyBoxMat->getName());
01167 scene->O3MaterialManager->unload(scene->skyBoxMat->getName());
01168 }
01169 }
01170 else
01171 {
01172 scene->O3SceneManager->getSkyBoxNode()->setVisible(true);
01173 scene->O3SceneManager->setSkyBox(true,scene->skyBoxMat->getName());
01174 }
01175 MMset(m,0,1);
01176 return 0;
01177 }
01178 }
01179 }
01180 catch(Ogre::Exception &e)
01181 {
01182 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01183 }
01184 MMset(m,0,0);
01185 return 0;
01186 }
01187
01188
01202 int SO3SceneGetSkyBoxParameters(mmachine m)
01203 {
01204 #if SO3_DEBUG == 1
01205 MMechostr(MSKDEBUG,"SO3SceneGetSkyBoxParameters\n");
01206 #endif
01207
01208 int s = MMget(m,0);
01209 if((s==NIL))
01210 {
01211 MMset(m,0,NIL);
01212 return 0;
01213 }
01214 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01215 if(scene==NULL)
01216 {
01217 MMset(m,0,NIL);
01218 return 0;
01219 }
01220
01221 try
01222 {
01223 if(scene->hasSkyBox)
01224 {
01225
01226
01227 SMaterial* curMat = scene->GetMaterial("General", scene->skyBoxMat->getName().c_str());
01228 int mat = OBJfindTH(m, SO3MATERIAL, (int)(curMat));
01229 if(mat!=NIL)
01230 mat = MMfetch(m,mat,OFFOBJMAG);
01231 MMpush(m, mat);
01232
01233 float d = scene->O3SceneManager->getSkyBoxGenParameters().skyBoxDistance;
01234 MMpush(m, FTOM(d));
01235
01236 Ogre::Quaternion orient;
01237 orient = scene->O3SceneManager->getSkyBoxNode()->getOrientation();
01238 int or = MMmalloc(m, 4, TYPETAB);
01239 if(or==NIL)
01240 {
01241 MMset(m,0,NIL);
01242 return MERRMEM;
01243 }
01244 MMstore(m, or, 0, FTOM(orient.x));
01245 MMstore(m, or, 1, FTOM(orient.y));
01246 MMstore(m, or, 2, FTOM(orient.z));
01247 MMstore(m, or, 3, FTOM(orient.w));
01248 MMpush(m, PTOM(or));
01249
01250 int booleenEnable = 0;
01251 if(scene->O3SceneManager->isSkyBoxEnabled())
01252 booleenEnable = 1;
01253 MMpush(m, ITOM(booleenEnable));
01254
01255 int booleenDrawFirst = 0;
01256 if(scene->skyBoxDrawFirst)
01257 booleenDrawFirst = 1;
01258 MMpush(m, ITOM(booleenDrawFirst));
01259
01260
01261 int tuple = MMmalloc(m, 5, TYPETAB);
01262 if(tuple==NIL)
01263 {
01264 MMset(m,0,NIL);
01265 return MERRMEM;
01266 }
01267 MMstore(m, tuple, 4, MMpull(m) );
01268 MMstore(m, tuple, 3, MMpull(m) );
01269 MMstore(m, tuple, 2, MMpull(m) );
01270 MMstore(m, tuple, 1, MMpull(m) );
01271 MMstore(m, tuple, 0, MMpull(m) );
01272 MMset(m,0,PTOM(tuple));
01273 return 0;
01274 }
01275 else
01276 {
01277 MMset(m,0,NIL);
01278 return 0;
01279 }
01280 }
01281 catch(Ogre::Exception &e)
01282 {
01283 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01284 MMset(m,0,0);
01285 return 0;
01286 }
01287 }
01288
01289
01309 int SO3SceneSetSkyDome(mmachine m)
01310 {
01311 #if SO3_DEBUG == 1
01312 MMechostr(MSKDEBUG,"SO3SceneSetSkyDome\n");
01313 #endif
01314
01315 int drawFirst = MTOI(MMpull(m));
01316 int booleen = MTOI(MMpull(m));
01317 int group = MMpull(m);
01318 int yKeep = MTOI(MMpull(m));
01319 int ySeg = MTOI(MMpull(m));
01320 int xSeg = MTOI(MMpull(m));
01321 float tiling = MTOF(MMpull(m));
01322 float curvature = MTOF(MMpull(m));
01323 int orient = MTOP(MMpull(m));
01324 float dist = MTOF(MMpull(m));
01325 int mat = MMpull(m);
01326 int s = MMget(m,0);
01327 if((s==NIL) || (mat==NIL))
01328 {
01329 MMset(m,0,NIL);
01330 return 0;
01331 }
01332 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01333 if(scene==NULL)
01334 {
01335 MMset(m,0,NIL);
01336 return 0;
01337 }
01338 SMaterial * material = (SMaterial*) MMfetch(m,MTOP(mat),0);
01339 if(material==NULL)
01340 {
01341 MMechostr(MSKDEBUG,"material==NULL\n");
01342 MMset(m,0,NIL);
01343 return 0;
01344 }
01345
01346 std::string groupResource("General");
01347
01348
01349
01350
01351
01352
01353
01354 Ogre::Quaternion quat;
01355 if(orient == NIL)
01356 quat = Ogre::Quaternion::IDENTITY;
01357 else
01358 {
01359 quat.x = MTOF(MMfetch(m,orient,0));
01360 quat.y = MTOF(MMfetch(m,orient,1));
01361 quat.z = MTOF(MMfetch(m,orient,2));
01362 quat.w = MTOF(MMfetch(m,orient,3));
01363 }
01364 try
01365 {
01366 if(!material->getOgreMaterialPointer().isNull())
01367 {
01368
01369 if(!scene->skyDomeMat.isNull())
01370 {
01371 scene->O3MaterialManager->remove(scene->skyDomeMat->getName());
01372 scene->O3MaterialManager->unload(scene->skyDomeMat->getName());
01373 }
01374
01375
01376 Ogre::MaterialPtr mCurrentMaterialPointer = material->getOgreMaterialPointer()->clone("mSkyDomeMaterial_" + material->getOgreMaterialPointer()->getName(), true, groupResource);
01377
01378 if(booleen == 0 && drawFirst == 0)
01379 {
01380 scene->O3SceneManager->setSkyDome(false,mCurrentMaterialPointer->getName(),curvature,tiling,dist,false,quat,xSeg,ySeg,yKeep,groupResource);
01381 scene->skyDomeDrawFirst = false;
01382 }
01383 else if(booleen == 0 && drawFirst != 0)
01384 {
01385 scene->O3SceneManager->setSkyDome(false,mCurrentMaterialPointer->getName(),curvature,tiling,dist,true,quat,xSeg,ySeg,yKeep,groupResource);
01386 scene->skyDomeDrawFirst = true;
01387 }
01388 else if(booleen != 0 && drawFirst == 0)
01389 {
01390 scene->O3SceneManager->setSkyDome(true,mCurrentMaterialPointer->getName(),curvature,tiling,dist,false,quat,xSeg,ySeg,yKeep,groupResource);
01391 scene->skyDomeDrawFirst = false;
01392 }
01393 else
01394 {
01395 scene->O3SceneManager->setSkyDome(true,mCurrentMaterialPointer->getName(),curvature,tiling,dist,true,quat,xSeg,ySeg,yKeep,groupResource);
01396 scene->skyDomeDrawFirst = true;
01397 }
01398 scene->hasSkyDome = true;
01399 scene->skyDomeMat = mCurrentMaterialPointer;
01400 }
01401 MMset(m,0,1);
01402 return 0;
01403 }
01404 catch(Ogre::Exception &e)
01405 {
01406 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01407 MMset(m,0,0);
01408 return 0;
01409 }
01410 }
01411
01412
01422 int SO3SceneSetSkyDomeEnable(mmachine m)
01423 {
01424 #if SO3_DEBUG == 1
01425 MMechostr(MSKDEBUG,"SO3SceneSetSkyDomeEnable\n");
01426 #endif
01427
01428 int booleen = MTOI(MMpull(m));
01429 int s = MMget(m,0);
01430 if((s==NIL) || (booleen==NIL))
01431 {
01432 MMset(m,0,NIL);
01433 return 0;
01434 }
01435 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01436 if(scene==NULL)
01437 {
01438 MMset(m,0,NIL);
01439 return 0;
01440 }
01441 if(scene->skyDomeMat.isNull())
01442 {
01443 MMset(m,0,NIL);
01444 return 0;
01445 }
01446 if(scene->O3MaterialManager->getByName(scene->skyDomeMat->getName()).isNull())
01447 {
01448 MMset(m,0,NIL);
01449 return 0;
01450 }
01451 try
01452 {
01453 if(scene->hasSkyDome)
01454 {
01455 if(scene->O3SceneManager->getSkyDomeNode() != 0)
01456 {
01457 if(booleen == 0)
01458 {
01459 scene->O3SceneManager->getSkyDomeNode()->setVisible(false);
01460 scene->O3SceneManager->setSkyDome(false,"");
01461 if(!scene->skyDomeMat.isNull())
01462 {
01463 scene->O3MaterialManager->remove(scene->skyDomeMat->getName());
01464 scene->O3MaterialManager->unload(scene->skyDomeMat->getName());
01465 }
01466 }
01467 else
01468 {
01469 scene->O3SceneManager->getSkyDomeNode()->setVisible(true);
01470 scene->O3SceneManager->setSkyDome(true,scene->skyDomeMat->getName(),scene->O3SceneManager->getSkyDomeGenParameters().skyDomeCurvature,scene->O3SceneManager->getSkyDomeGenParameters().skyDomeTiling,scene->O3SceneManager->getSkyDomeGenParameters().skyDomeDistance);
01471 }
01472 }
01473 MMset(m,0,1);
01474 return 0;
01475 }
01476 }
01477 catch(Ogre::Exception &e)
01478 {
01479 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01480 }
01481 MMset(m,0,0);
01482 return 0;
01483 }
01484
01485
01504 int SO3SceneGetSkyDomeParameters(mmachine m)
01505 {
01506 #if SO3_DEBUG == 1
01507 MMechostr(MSKDEBUG,"SO3SceneGetSkyDomeParameters\n");
01508 #endif
01509
01510 int s = MMget(m,0);
01511 if((s==NIL))
01512 {
01513 MMset(m,0,NIL);
01514 return 0;
01515 }
01516 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01517 if(scene==NULL)
01518 {
01519 MMset(m,0,NIL);
01520 return 0;
01521 }
01522
01523 try
01524 {
01525 if(scene->hasSkyDome)
01526 {
01527
01528
01529 SMaterial * curMat = scene->GetMaterial("General", scene->skyDomeMat->getName().c_str());
01530 int mat = OBJfindTH(m, SO3MATERIAL, (int)(curMat));
01531 if(mat!=NIL)
01532 mat = MMfetch(m,mat,OFFOBJMAG);
01533 MMpush(m, mat);
01534
01535 float curvature = scene->O3SceneManager->getSkyDomeGenParameters().skyDomeCurvature;
01536 MMpush(m, FTOM(curvature));
01537
01538 float tilling = scene->O3SceneManager->getSkyDomeGenParameters().skyDomeTiling;
01539 MMpush(m, FTOM(tilling));
01540
01541 float d = scene->O3SceneManager->getSkyDomeGenParameters().skyDomeDistance;
01542 MMpush(m, FTOM(d));
01543
01544 int xSeg = scene->O3SceneManager->getSkyDomeGenParameters().skyDomeXSegments;
01545 MMpush(m, ITOM(xSeg));
01546
01547 int ySeg = scene->O3SceneManager->getSkyDomeGenParameters().skyDomeYSegments;
01548 MMpush(m, ITOM(ySeg));
01549
01550 int keep = scene->O3SceneManager->getSkyDomeGenParameters().skyDomeYSegments_keep;
01551 MMpush(m, ITOM(keep));
01552
01553 Ogre::Quaternion orient;
01554 orient = scene->O3SceneManager->getSkyDomeNode()->getOrientation();
01555 int or = MMmalloc(m, 4, TYPETAB);
01556 if(or==NIL)
01557 {
01558 MMset(m,0,NIL);
01559 return MERRMEM;
01560 }
01561 MMstore(m, or, 0, FTOM(orient.x));
01562 MMstore(m, or, 1, FTOM(orient.y));
01563 MMstore(m, or, 2, FTOM(orient.z));
01564 MMstore(m, or, 3, FTOM(orient.w));
01565 MMpush(m, PTOM(or));
01566
01567 int booleenEnable = 0;
01568 if(scene->O3SceneManager->isSkyDomeEnabled())
01569 booleenEnable = 1;
01570 MMpush(m, ITOM(booleenEnable));
01571
01572 int booleenDrawFirst = 0;
01573 if(scene->skyDomeDrawFirst)
01574 booleenDrawFirst = 1;
01575 MMpush(m, ITOM(booleenDrawFirst));
01576
01577
01578 int tuple = MMmalloc(m, 10, TYPETAB);
01579 if(tuple==NIL)
01580 {
01581 MMset(m,0,NIL);
01582 return MERRMEM;
01583 }
01584 MMstore(m, tuple, 9, MMpull(m) );
01585 MMstore(m, tuple, 8, MMpull(m) );
01586 MMstore(m, tuple, 7, MMpull(m) );
01587 MMstore(m, tuple, 6, MMpull(m) );
01588 MMstore(m, tuple, 5, MMpull(m) );
01589 MMstore(m, tuple, 4, MMpull(m) );
01590 MMstore(m, tuple, 3, MMpull(m) );
01591 MMstore(m, tuple, 2, MMpull(m) );
01592 MMstore(m, tuple, 1, MMpull(m) );
01593 MMstore(m, tuple, 0, MMpull(m) );
01594 MMset(m,0,PTOM(tuple));
01595 return 0;
01596 }
01597 else
01598 {
01599 MMset(m,0,NIL);
01600 return 0;
01601 }
01602
01603 }
01604 catch(Ogre::Exception &e)
01605 {
01606 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01607 MMset(m,0,0);
01608 return 0;
01609 }
01610 }
01611
01612
01632 int SO3SceneSetSkyPlane(mmachine m)
01633 {
01634 #if SO3_DEBUG == 1
01635 MMechostr(MSKDEBUG,"SO3SceneSetSkyPlane\n");
01636 #endif
01637
01638 int drawFirst = MTOI(MMpull(m));
01639 int booleen = MTOI(MMpull(m));
01640 int group = MMpull(m);
01641 int ySeg = MTOI(MMpull(m));
01642 int xSeg = MTOI(MMpull(m));
01643 float bow = MTOF(MMpull(m));
01644 float tiling = MTOF(MMpull(m));
01645 float scale = MTOF(MMpull(m));
01646 int vec = MTOP(MMpull(m));
01647 float d = MTOF(MMpull(m));
01648 int mat = MMpull(m);
01649 int s = MMget(m,0);
01650 if((s==NIL) || (mat==NIL))
01651 {
01652 MMset(m,0,NIL);
01653 return 0;
01654 }
01655 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01656 if(scene==NULL)
01657 {
01658 MMset(m,0,NIL);
01659 return 0;
01660 }
01661 SMaterial * material = (SMaterial*) MMfetch(m,MTOP(mat),0);
01662 if(material==NULL)
01663 {
01664 MMechostr(MSKDEBUG,"material==NULL\n");
01665 MMset(m,0,NIL);
01666 return 0;
01667 }
01668
01669 std::string groupResource("General");
01670
01671
01672
01673
01674
01675
01676 try
01677 {
01678 if(!material->getOgreMaterialPointer().isNull())
01679 {
01680
01681 if(!scene->skyPlaneMat.isNull())
01682 {
01683 scene->O3MaterialManager->remove(scene->skyPlaneMat->getName());
01684 scene->O3MaterialManager->unload(scene->skyPlaneMat->getName());
01685 }
01686
01687
01688 Ogre::MaterialPtr mCurrentMaterialPointer = material->getOgreMaterialPointer()->clone("mSkyPlaneMaterial_" + material->getOgreMaterialPointer()->getName(), true, groupResource);
01689
01690 Ogre::Plane plane;
01691 Ogre::Vector3 vecteur;
01692 if(vec == NIL)
01693 {
01694 vecteur.NEGATIVE_UNIT_Y;
01695 }
01696 else
01697 {
01698 vecteur.x = MTOF(MMfetch(m,vec,0));
01699 vecteur.y = MTOF(MMfetch(m,vec,1));
01700 vecteur.z = MTOF(MMfetch(m,vec,2));
01701 }
01702 plane.d = d;
01703 plane.normal = vecteur;
01704
01705 if(booleen == 0 && drawFirst == 0)
01706 {
01707 scene->O3SceneManager->setSkyPlane(false,plane,mCurrentMaterialPointer->getName(),scale,tiling,false,bow,xSeg,ySeg,groupResource);
01708 scene->skyPlaneDrawFirst = false;
01709 }
01710 else if(booleen == 0 && drawFirst != 0)
01711 {
01712 scene->O3SceneManager->setSkyPlane(false,plane,mCurrentMaterialPointer->getName(),scale,tiling,true,bow,xSeg,ySeg,groupResource);
01713 scene->skyPlaneDrawFirst = true;
01714 }
01715 else if(booleen != 0 && drawFirst == 0)
01716 {
01717 scene->O3SceneManager->setSkyPlane(true,plane,mCurrentMaterialPointer->getName(),scale,tiling,false,bow,xSeg,ySeg,groupResource);
01718 scene->skyPlaneDrawFirst = false;
01719 }
01720 else
01721 {
01722 scene->O3SceneManager->setSkyPlane(true,plane,mCurrentMaterialPointer->getName(),scale,tiling,true,bow,xSeg,ySeg,groupResource);
01723 scene->skyPlaneDrawFirst = true;
01724 }
01725
01726
01727 scene->hasSkyPlane = true;
01728 scene->skyPlaneMat = mCurrentMaterialPointer;
01729 scene->skyPlane = plane;
01730
01731 }
01732 MMset(m,0,1);
01733 return 0;
01734 }
01735 catch(Ogre::Exception &e)
01736 {
01737 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01738 MMset(m,0,0);
01739 return 0;
01740 }
01741 }
01742
01743
01753 int SO3SceneSetSkyPlaneEnable(mmachine m)
01754 {
01755 #if SO3_DEBUG == 1
01756 MMechostr(MSKDEBUG,"SO3SceneSetSkyPlaneEnable\n");
01757 #endif
01758
01759
01760 int booleen = MTOI(MMpull(m));
01761 int s = MMget(m,0);
01762 if((s==NIL) || (booleen==NIL))
01763 {
01764 MMset(m,0,NIL);
01765 return 0;
01766 }
01767 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01768 if(scene==NULL)
01769 {
01770 MMset(m,0,NIL);
01771 return 0;
01772 }
01773 if(scene->skyPlaneMat.isNull())
01774 {
01775 MMset(m,0,NIL);
01776 return 0;
01777 }
01778 if(scene->O3MaterialManager->getByName(scene->skyPlaneMat->getName()).isNull())
01779 {
01780 MMset(m,0,NIL);
01781 return 0;
01782 }
01783
01784 try
01785 {
01786 if(scene->hasSkyPlane)
01787 {
01788 if(scene->O3SceneManager->getSkyPlaneNode()!=0)
01789 {
01790 if(booleen == 0)
01791 {
01792 scene->O3SceneManager->getSkyPlaneNode()->setVisible(false);
01793 scene->O3SceneManager->setSkyPlane(false,scene->skyPlane,"");
01794 if(!scene->skyPlaneMat.isNull())
01795 {
01796 scene->O3MaterialManager->remove(scene->skyPlaneMat->getName());
01797 scene->O3MaterialManager->unload(scene->skyPlaneMat->getName());
01798 }
01799 }
01800 else
01801 {
01802 scene->O3SceneManager->getSkyPlaneNode()->setVisible(true);
01803 scene->O3SceneManager->setSkyPlane(true,scene->skyPlane,scene->skyPlaneMat->getName());
01804 }
01805 MMset(m,0,1);
01806 return 0;
01807 }
01808 }
01809 }
01810 catch(Ogre::Exception &e)
01811 {
01812 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01813 }
01814 MMset(m,0,0);
01815 return 0;
01816 }
01817
01818
01837 int SO3SceneGetSkyPlaneParameters(mmachine m)
01838 {
01839 #if SO3_DEBUG == 1
01840 MMechostr(MSKDEBUG,"SO3SceneGetSkyPlaneParameters\n");
01841 #endif
01842
01843 int s = MMget(m,0);
01844 if((s==NIL))
01845 {
01846 MMset(m,0,NIL);
01847 return 0;
01848 }
01849 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01850 if(scene==NULL)
01851 {
01852 MMset(m,0,NIL);
01853 return 0;
01854 }
01855
01856 MMpull(m);
01857
01858 try
01859 {
01860 if(scene->hasSkyPlane)
01861 {
01862
01863
01864 SMaterial * curMat = scene->GetMaterial("General", scene->skyPlaneMat->getName().c_str());
01865 createOrRetrieveScolMaterialAndSendToVM(m, scene, curMat);
01866
01867 float bow = scene->O3SceneManager->getSkyPlaneGenParameters().skyPlaneBow;
01868 MMpush(m, FTOM(bow));
01869
01870 float scale = scene->O3SceneManager->getSkyPlaneGenParameters().skyPlaneScale;
01871 MMpush(m, FTOM(scale));
01872
01873 float tiling = scene->O3SceneManager->getSkyPlaneGenParameters().skyPlaneTiling;
01874 MMpush(m, FTOM(tiling));
01875
01876 int xSeg = scene->O3SceneManager->getSkyPlaneGenParameters().skyPlaneXSegments;
01877 MMpush(m, ITOM(xSeg));
01878
01879 int ySeg = scene->O3SceneManager->getSkyPlaneGenParameters().skyPlaneYSegments;
01880 MMpush(m, ITOM(ySeg));
01881
01882 float d = scene->skyPlane.d;
01883 MMpush(m, FTOM(d));
01884
01885 Ogre::Vector3 vec;
01886 vec = scene->skyPlane.normal;
01887 int vecteur = MMmalloc(m, 3, TYPETAB);
01888 if(vecteur==NIL)
01889 {
01890 MMpush(m, NIL);
01891 return MERRMEM;
01892 }
01893 MMstore(m, vecteur, 0, FTOM(vec.x));
01894 MMstore(m, vecteur, 1, FTOM(vec.y));
01895 MMstore(m, vecteur, 2, FTOM(vec.z));
01896 MMpush(m, PTOM(vecteur));
01897
01898 int booleenEnable = 0;
01899 if(scene->O3SceneManager->isSkyPlaneEnabled())
01900 booleenEnable = 1;
01901 MMpush(m, ITOM(booleenEnable));
01902
01903 int booleenDrawFirst = 0;
01904 if(scene->skyBoxDrawFirst)
01905 booleenDrawFirst = 1;
01906 MMpush(m, ITOM(booleenDrawFirst));
01907
01908
01909 int tuple = MMmalloc(m, 10, TYPETAB);
01910 if(tuple==NIL)
01911 {
01912 MMpush(m, NIL);
01913 return MERRMEM;
01914 }
01915 MMstore(m, tuple, 9, MMpull(m) );
01916 MMstore(m, tuple, 8, MMpull(m) );
01917 MMstore(m, tuple, 7, MMpull(m) );
01918 MMstore(m, tuple, 6, MMpull(m) );
01919 MMstore(m, tuple, 5, MMpull(m) );
01920 MMstore(m, tuple, 4, MMpull(m) );
01921 MMstore(m, tuple, 3, MMpull(m) );
01922 MMstore(m, tuple, 2, MMpull(m) );
01923 MMstore(m, tuple, 1, MMpull(m) );
01924 MMstore(m, tuple, 0, MMpull(m) );
01925 MMpush(m,PTOM(tuple));
01926 return 0;
01927 }
01928 else
01929 {
01930 MMpush(m, NIL);
01931 return 0;
01932 }
01933
01934 }
01935 catch(Ogre::Exception &e)
01936 {
01937 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
01938 MMpush(m, NIL);
01939 return 0;
01940 }
01941 }
01942
01943
01953 int SO3SceneSetAmbientLight(mmachine m)
01954 {
01955 #ifdef SO3_DEBUG
01956 MMechostr(MSKDEBUG,"SO3SceneSetAmbientLight\n");
01957 #endif
01958
01959 int ambient = MTOI(MMpull(m));
01960 int s = MMget(m,0);
01961 if((s == NIL) || (ambient==NIL))
01962 {
01963 MMset(m,0,NIL);
01964 return 0;
01965 }
01966 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
01967 if(scene==NULL)
01968 {
01969 MMset(m,0,NIL);
01970 return 0;
01971 }
01972 float r,g,b,a = 0.0;
01973 r = ((ambient>>23)&0x000000ff) / CONST_COLOR;
01974 g = ((ambient>>15)&0x000000ff) / CONST_COLOR;
01975 b = ((ambient>>7 )&0x000000ff) / CONST_COLOR;
01976 a = ((ambient )&0x0000007E) / CONST_COLOR_ALPHA;
01977 Ogre::ColourValue ambientColor;
01978 ambientColor.a = a;
01979 ambientColor.r = r;
01980 ambientColor.g = g;
01981 ambientColor.b = b;
01982 scene->O3SceneManager->setAmbientLight(ambientColor);
01983 MMset(m,0,1);
01984 return 0;
01985 }
01986
01987
01996 int SO3SceneGetAmbientLight(mmachine m)
01997 {
01998 #ifdef SO3_DEBUG
01999 MMechostr(MSKDEBUG,"SO3SceneGetAmbientLight\n");
02000 #endif
02001
02002 int s = MMget(m,0);
02003 if((s==NIL))
02004 {
02005 MMset(m,0,0);
02006 return 0;
02007 }
02008 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02009 if(scene==NULL)
02010 {
02011 MMset(m,0,0);
02012 return 0;
02013 }
02014
02015 int a = static_cast <int> (scene->O3SceneManager->getAmbientLight().a*CONST_COLOR_ALPHA);
02016 int b = static_cast <int> (scene->O3SceneManager->getAmbientLight().b*CONST_COLOR);
02017 int g = static_cast <int> (scene->O3SceneManager->getAmbientLight().g*CONST_COLOR);
02018 int r = static_cast <int> (scene->O3SceneManager->getAmbientLight().r*CONST_COLOR);
02019
02020 int val = (a&0x0000007E) + ((b&0x000000ff)<<7) + ((g&0x000000ff)<<15) + ((r&0x000000ff)<<23);
02021
02022 MMset(m,0,ITOM(val));
02023 return 0;
02024 }
02025
02026
02035 int SO3SceneGetFogColor(mmachine m)
02036 {
02037 #ifdef SO3_DEBUG
02038 MMechostr(MSKDEBUG,"SO3SceneGetFogColor\n");
02039 #endif
02040
02041 int s = MMget(m,0);
02042 if((s==NIL))
02043 {
02044 MMset(m,0,0);
02045 return 0;
02046 }
02047 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02048 if(scene==NULL)
02049 {
02050 MMset(m,0,0);
02051 return 0;
02052 }
02053
02054 int a = static_cast <int> (scene->O3SceneManager->getFogColour().a*CONST_COLOR_ALPHA);
02055 int b = static_cast <int> (scene->O3SceneManager->getFogColour().b*CONST_COLOR);
02056 int g = static_cast <int> (scene->O3SceneManager->getFogColour().g*CONST_COLOR);
02057 int r = static_cast <int> (scene->O3SceneManager->getFogColour().r*CONST_COLOR);
02058
02059 int val = (a&0x0000007E) + ((b&0x000000ff)<<7) + ((g&0x000000ff)<<15) + ((r&0x000000ff)<<23);
02060
02061 MMset(m,0,ITOM(val));
02062 return 0;
02063 }
02064
02065
02080 int SO3SceneGetFogMode(mmachine m)
02081 {
02082 #ifdef SO3_DEBUG
02083 MMechostr(MSKDEBUG,"SO3SceneGetFogMode\n");
02084 #endif
02085
02086 int s = MMget(m,0);
02087 if((s==NIL))
02088 {
02089 MMset(m,0,0);
02090 return 0;
02091 }
02092 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02093 if(scene==NULL)
02094 {
02095 MMset(m,0,0);
02096 return 0;
02097 }
02098
02099 int val = (int)scene->O3SceneManager->getFogMode();
02100
02101 MMset(m,0,ITOM(val));
02102 return 0;
02103 }
02104
02105
02114 int SO3SceneGetFogDensity(mmachine m)
02115 {
02116 #ifdef SO3_DEBUG
02117 MMechostr(MSKDEBUG,"SO3SceneGetFogDensity\n");
02118 #endif
02119
02120 int s = MMget(m,0);
02121 if((s==NIL))
02122 {
02123 MMset(m,0,0);
02124 return 0;
02125 }
02126 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02127 if(scene==NULL)
02128 {
02129 MMset(m,0,0);
02130 return 0;
02131 }
02132
02133 float val = scene->O3SceneManager->getFogDensity();
02134
02135 MMset(m,0,FTOM(val));
02136 return 0;
02137 }
02138
02139
02148 int SO3SceneGetFogStart(mmachine m)
02149 {
02150 #ifdef SO3_DEBUG
02151 MMechostr(MSKDEBUG,"SO3SceneGetFogStart\n");
02152 #endif
02153
02154 int s = MMget(m,0);
02155 if((s==NIL))
02156 {
02157 MMset(m,0,0);
02158 return 0;
02159 }
02160 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02161 if(scene==NULL)
02162 {
02163 MMset(m,0,0);
02164 return 0;
02165 }
02166
02167 float val = scene->O3SceneManager->getFogStart();
02168
02169 MMset(m,0,FTOM(val));
02170 return 0;
02171 }
02172
02173
02182 int SO3SceneGetFogEnd(mmachine m)
02183 {
02184 #ifdef SO3_DEBUG
02185 MMechostr(MSKDEBUG,"SO3SceneGetFogEnd\n");
02186 #endif
02187
02188 int s = MMget(m,0);
02189 if((s==NIL))
02190 {
02191 MMset(m,0,0);
02192 return 0;
02193 }
02194 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02195 if(scene==NULL)
02196 {
02197 MMset(m,0,0);
02198 return 0;
02199 }
02200
02201 float val = scene->O3SceneManager->getFogEnd();
02202
02203 MMset(m,0,FTOM(val));
02204 return 0;
02205 }
02206
02207
02227 int SO3SceneSetFog(mmachine m)
02228 {
02229 #ifdef SO3_DEBUG
02230 MMechostr(MSKDEBUG,"SO3SceneSetFog\n");
02231 #endif
02232
02233 int linE = MMpull(m);
02234 int linS = MMpull(m);
02235 int expo = MMpull(m);
02236 int color = MTOI(MMpull(m));
02237 int mode = MTOI(MMpull(m));
02238 int s = MMget(m,0);
02239 if((s == NIL) || (color==NIL) || (expo==NIL) || (linS==NIL) || (linE==NIL) || (mode==NIL))
02240 {
02241 MMset(m,0,NIL);
02242 return 0;
02243 }
02244 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02245 if(scene==NULL)
02246 {
02247 MMset(m,0,NIL);
02248 return 0;
02249 }
02250 float r,g,b,a = 0.0;
02251 r = ((color>>23)&0x000000ff) / CONST_COLOR;
02252 g = ((color>>15)&0x000000ff) / CONST_COLOR;
02253 b = ((color>>7 )&0x000000ff) / CONST_COLOR;
02254 a = ((color )&0x0000007E) / CONST_COLOR_ALPHA;
02255 Ogre::ColourValue diffuseColor;
02256 diffuseColor.a = a;
02257 diffuseColor.r = r;
02258 diffuseColor.g = g;
02259 diffuseColor.b = b;
02260 scene->O3SceneManager->setFog((Ogre::FogMode)mode,diffuseColor,(Ogre::Real)MTOF(expo),(Ogre::Real)MTOF(linS),(Ogre::Real)MTOF(linE));
02261
02262 MMset(m,0,1);
02263 return 0;
02264 }
02265
02266
02276 int SO3SceneSetShadowColor(mmachine m)
02277 {
02278 #ifdef SO3_DEBUG
02279 MMechostr(MSKDEBUG,"SO3SceneSetShadowColor\n");
02280 #endif
02281
02282 int color = MTOI(MMpull(m));
02283 int s = MMget(m,0);
02284 if((s == NIL) || (color==NIL))
02285 {
02286 MMpush(m,NIL);
02287 return 0;
02288 }
02289 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02290 if(scene==NULL)
02291 {
02292 MMset(m,0,NIL);
02293 return 0;
02294 }
02295 float r,g,b,a = 0.0;
02296 r = ((color>>23)&0x000000ff) / CONST_COLOR;
02297 g = ((color>>15)&0x000000ff) / CONST_COLOR;
02298 b = ((color>>7 )&0x000000ff) / CONST_COLOR;
02299 a = ((color )&0x0000007E) / CONST_COLOR_ALPHA;
02300 Ogre::ColourValue mColor;
02301 mColor.a = a;
02302 mColor.r = r;
02303 mColor.g = g;
02304 mColor.b = b;
02305 scene->O3SceneManager->setShadowColour(mColor);
02306 MMset(m,0,1);
02307 return 0;
02308 }
02309
02310
02319 int SO3SceneGetShadowColor(mmachine m)
02320 {
02321 #ifdef SO3_DEBUG
02322 MMechostr(MSKDEBUG,"SO3SceneGetShadowColor\n");
02323 #endif
02324
02325 int s = MMget(m,0);
02326 if((s==NIL))
02327 {
02328 MMset(m,0,NIL);
02329 return 0;
02330 }
02331 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
02332 if(scene==NULL)
02333 {
02334 MMset(m,0,NIL);
02335 return 0;
02336 }
02337
02338 int a = static_cast <int> (scene->O3SceneManager->getShadowColour().a*CONST_COLOR_ALPHA);
02339 int b = static_cast <int> (scene->O3SceneManager->getShadowColour().b*CONST_COLOR);
02340 int g = static_cast <int> (scene->O3SceneManager->getShadowColour().g*CONST_COLOR);
02341 int r = static_cast <int> (scene->O3SceneManager->getShadowColour().r*CONST_COLOR);
02342
02343 int val = (a&0x0000007E) + ((b&0x000000ff)<<7) + ((g&0x000000ff)<<15) + ((r&0x000000ff)<<23);
02344
02345 MMset(m,0,ITOM(val));
02346 return 0;
02347 }
02348
02349
02359 int SO3SceneSetSelfShadowTexture(mmachine m)
02360 {
02361 #ifdef SO3_DEBUG
02362 MMechostr(MSKDEBUG,"SO3SceneSetSelfShadowTexture\n");
02363 #endif
02364
02365 int booleen = MTOI(MMpull(m));
02366 int s = MMget(m,0);
02367 if((s == NIL) || (booleen==NIL))
02368 {
02369 MMset(m,0,0);
02370 return 0;
02371 }
02372 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02373 if(scene==NULL)
02374 {
02375 MMset(m,0,NIL);
02376 return 0;
02377 }
02378
02379 if(booleen == SO3_FALSE)
02380 scene->O3SceneManager->setShadowTextureSelfShadow(false);
02381 else
02382 scene->O3SceneManager->setShadowTextureSelfShadow(true);
02383 MMset(m,0,1);
02384 return 0;
02385 }
02386
02387
02397 int SO3SceneSetShadowTextureCount(mmachine m)
02398 {
02399 #ifdef SO3_DEBUG
02400 MMechostr(MSKDEBUG,"SO3SceneSetShadowTextureCount\n");
02401 #endif
02402
02403 int val = MTOI(MMpull(m));
02404 int s = MMget(m,0);
02405 if((s == NIL) || (val==NIL))
02406 {
02407 MMset(m,0,0);
02408 return 0;
02409 }
02410 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02411 if(scene==NULL)
02412 {
02413 MMset(m,0,NIL);
02414 return 0;
02415 }
02416 try
02417 {
02418 if(val == 0)
02419 Ogre::ShadowTextureManager::getSingleton().clear();
02420 else
02421 scene->O3SceneManager->setShadowTextureCount(val);
02422 }
02423 catch(Ogre::Exception &e)
02424 {
02425 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
02426 MMset(m,0,0);
02427 return 0;
02428 }
02429
02430 MMset(m,0,1);
02431 return 0;
02432 }
02433
02434
02444 int SO3SceneSetShadowTextureSize(mmachine m)
02445 {
02446 #ifdef SO3_DEBUG
02447 MMechostr(MSKDEBUG,"SO3SceneSetShadowTextureSize\n");
02448 #endif
02449
02450 int val = MTOI(MMpull(m));
02451 int s = MMget(m,0);
02452 if((s == NIL) || (val==NIL))
02453 {
02454 MMset(m,0,0);
02455 return 0;
02456 }
02457 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02458 if(scene==NULL)
02459 {
02460 MMset(m,0,NIL);
02461 return 0;
02462 }
02463 try
02464 {
02465 scene->O3SceneManager->setShadowTextureSize(val);
02466 }
02467 catch(Ogre::Exception &e)
02468 {
02469 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
02470 MMset(m,0,0);
02471 return 0;
02472 }
02473 MMset(m,0,1);
02474 return 0;
02475 }
02476
02477
02486 int SO3SceneSetDefaultShadowCamera(mmachine m)
02487 {
02488 #ifdef SO3_DEBUG
02489 MMechostr(MSKDEBUG,"SO3SceneSetDefaultShadowCamera\n");
02490 #endif
02491
02492 int s = MMget(m,0);
02493 if((s == NIL))
02494 {
02495 MMset(m,0,0);
02496 return 0;
02497 }
02498 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02499 if(scene==NULL)
02500 {
02501 MMset(m,0,NIL);
02502 return 0;
02503 }
02504 try
02505 {
02506 int flag = scene->O3SceneManager->getShadowTechnique();
02507 scene->O3SceneManager->setShadowTechnique(Ogre::SHADOWTYPE_NONE);
02508 Ogre::ShadowTextureManager::getSingleton().clear();
02509 scene->O3SceneManager->setShadowTechnique((Ogre::ShadowTechnique)flag);
02510 scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::DefaultShadowCameraSetup()));
02511 scene->shadowCameraSetup = SO3_DEFAULT_SHADOW_CAMERA;
02512 }
02513 catch(Ogre::Exception &e)
02514 {
02515 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
02516 MMset(m,0,0);
02517 return 0;
02518 }
02519 MMset(m,0,1);
02520 return 0;
02521 }
02522
02523
02532 int SO3SceneSetFocusedShadowCamera(mmachine m)
02533 {
02534 #ifdef SO3_DEBUG
02535 MMechostr(MSKDEBUG,"SO3SceneSetFocusedShadowCamera\n");
02536 #endif
02537
02538 int s = MMget(m,0);
02539 if((s == NIL))
02540 {
02541 MMset(m,0,0);
02542 return 0;
02543 }
02544 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02545 if(scene==NULL)
02546 {
02547 MMset(m,0,NIL);
02548 return 0;
02549 }
02550 try
02551 {
02552 scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::FocusedShadowCameraSetup()));
02553 scene->shadowCameraSetup = SO3_FOCUSED_SHADOW_CAMERA;
02554 }
02555 catch(Ogre::Exception &e)
02556 {
02557 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
02558 MMset(m,0,0);
02559 return 0;
02560 }
02561 MMset(m,0,1);
02562 return 0;
02563 }
02564
02565
02574 int SO3SceneSetLISPSMShadowCamera(mmachine m)
02575 {
02576 #ifdef SO3_DEBUG
02577 MMechostr(MSKDEBUG,"SO3SceneSetLISPSMShadowCamera\n");
02578 #endif
02579
02580 int s = MMget(m,0);
02581 if((s == NIL))
02582 {
02583 MMset(m,0,0);
02584 return 0;
02585 }
02586 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02587 if(scene==NULL)
02588 {
02589 MMset(m,0,NIL);
02590 return 0;
02591 }
02592 try
02593 {
02594 scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::LiSPSMShadowCameraSetup()));
02595 scene->shadowCameraSetup = SO3_LISPSM_SHADOW_CAMERA;
02596 }
02597 catch(Ogre::Exception &e)
02598 {
02599 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
02600 MMset(m,0,0);
02601 return 0;
02602 }
02603 MMset(m,0,1);
02604 return 0;
02605 }
02606
02607
02618 int SO3SceneSetPlaneShadowCamera(mmachine m)
02619 {
02620 #ifdef SO3_DEBUG
02621 MMechostr(MSKDEBUG,"SO3SceneSetPlaneShadowCamera\n");
02622 #endif
02623
02624 int d = MMpull(m);
02625 int vec = MTOP(MMpull(m));
02626 int s = MMget(m,0);
02627 if((s == NIL) || (d==NIL))
02628 {
02629 MMset(m,0,NIL);
02630 return 0;
02631 }
02632 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02633 if(scene==NULL)
02634 {
02635 MMset(m,0,NIL);
02636 return 0;
02637 }
02638 try
02639 {
02640
02641 Ogre::MovablePlane* plane = OGRE_NEW Ogre::MovablePlane("PlaneShadowCamera");
02642 Ogre::Vector3 vecteur;
02643 if(vec == NIL)
02644 {
02645 vecteur.NEGATIVE_UNIT_Y;
02646 }
02647 else
02648 {
02649 vecteur.x = MTOF(MMfetch(m,vec,0));
02650 vecteur.y = MTOF(MMfetch(m,vec,1));
02651 vecteur.z = MTOF(MMfetch(m,vec,2));
02652 }
02653 plane->d = MTOF(d);
02654 plane->normal = vecteur;
02655
02656 scene->O3SceneManager->setShadowCameraSetup(Ogre::ShadowCameraSetupPtr(OGRE_NEW Ogre::PlaneOptimalShadowCameraSetup(plane)));
02657 scene->shadowCameraSetup = SO3_PLANE_SHADOW_CAMERA;
02658 }
02659 catch(Ogre::Exception &e)
02660 {
02661 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
02662 MMset(m,0,0);
02663 return 0;
02664 }
02665
02666 MMset(m,0,ITOM(1));
02667 return 0;
02668 }
02669
02670
02680 int SO3SceneSetShadowDirectionalLightExtrusionDistance(mmachine m)
02681 {
02682 #ifdef SO3_DEBUG
02683 MMechostr(MSKDEBUG,"SO3SceneSetShadowDirectionalLightExtrusionDistance\n");
02684 #endif
02685
02686 int val = MMpull(m);
02687 int s = MMget(m,0);
02688 if((s == NIL) || (val==NIL))
02689 {
02690 MMset(m,0,0);
02691 return 0;
02692 }
02693 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02694 if(scene==NULL)
02695 {
02696 MMset(m,0,NIL);
02697 return 0;
02698 }
02699 scene->O3SceneManager->setShadowDirectionalLightExtrusionDistance(MTOF(val));
02700 MMset(m,0,1);
02701 return 0;
02702 }
02703
02704
02714 int SO3SceneSetShadowFarDistance(mmachine m)
02715 {
02716 #ifdef SO3_DEBUG
02717 MMechostr(MSKDEBUG,"SO3SceneSetShadowFarDistance\n");
02718 #endif
02719
02720 int val = MMpull(m);
02721 int s = MMget(m,0);
02722 if((s == NIL) || (val==NIL))
02723 {
02724 MMset(m,0,NIL);
02725 return 0;
02726 }
02727 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02728 if(scene==NULL)
02729 {
02730 MMset(m,0,NIL);
02731 return 0;
02732 }
02733 scene->O3SceneManager->setShadowFarDistance(MTOF(val));
02734 MMset(m,0,1);
02735 return 0;
02736 }
02737
02738
02748 int SO3SceneSetShadowTextureFadeStart(mmachine m)
02749 {
02750 #ifdef SO3_DEBUG
02751 MMechostr(MSKDEBUG,"SO3SceneSetShadowTextureFadeStart\n");
02752 #endif
02753
02754 int val = MMpull(m);
02755 int s = MMget(m,0);
02756 if((s == NIL) || (val==NIL))
02757 {
02758 MMset(m,0,NIL);
02759 return 0;
02760 }
02761 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02762 if(scene==NULL)
02763 {
02764 MMset(m,0,NIL);
02765 return 0;
02766 }
02767 scene->O3SceneManager->setShadowTextureFadeStart(MTOF(val));
02768 MMset(m,0,1);
02769 return 0;
02770 }
02771
02772
02795 int SO3SceneGetShadowTechnique(mmachine m)
02796 {
02797 #ifdef SO3_DEBUG
02798 MMechostr(MSKDEBUG,"SO3SceneGetShadowTechnique\n");
02799 #endif
02800
02801 int s = MMget(m,0);
02802 if((s == NIL))
02803 {
02804 MMset(m,0,NIL);
02805 return 0;
02806 }
02807 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02808 if(scene==NULL)
02809 {
02810 MMset(m,0,NIL);
02811 return 0;
02812 }
02813 if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_NONE )
02814 MMset(m,0,ITOM(SO3_SHADOWTYPE_NONE));
02815 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_ADDITIVE )
02816 MMset(m,0,ITOM(SO3_SHADOWDETAILTYPE_ADDITIVE));
02817 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_MODULATIVE )
02818 MMset(m,0,ITOM(SO3_SHADOWDETAILTYPE_MODULATIVE));
02819 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_STENCIL )
02820 MMset(m,0,ITOM(SO3_SHADOWDETAILTYPE_STENCIL));
02821 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_TEXTURE )
02822 MMset(m,0,ITOM(SO3_SHADOWDETAILTYPE_TEXTURE));
02823 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_STENCIL_MODULATIVE )
02824 MMset(m,0,ITOM(SO3_SHADOWTYPE_STENCIL_MODULATIVE));
02825 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_STENCIL_ADDITIVE )
02826 MMset(m,0,ITOM(SO3_SHADOWTYPE_STENCIL_ADDITIVE));
02827 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_MODULATIVE )
02828 MMset(m,0,ITOM(SO3_SHADOWTYPE_TEXTURE_MODULATIVE));
02829 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_ADDITIVE )
02830 MMset(m,0,ITOM(SO3_SHADOWTYPE_TEXTURE_ADDITIVE));
02831 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED )
02832 MMset(m,0,ITOM(SO3_SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED));
02833 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWDETAILTYPE_ADDITIVE )
02834 MMset(m,0,ITOM(SO3_SHADOWDETAILTYPE_ADDITIVE));
02835 else if(scene->O3SceneManager->getShadowTechnique() == Ogre::SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED )
02836 MMset(m,0,ITOM(SO3_SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED));
02837 else
02838 MMset(m,0,NIL);
02839 return 0;
02840 }
02841
02842
02852 int SO3SceneSetShadowTextureFadeEnd(mmachine m)
02853 {
02854 #ifdef SO3_DEBUG
02855 MMechostr(MSKDEBUG,"SO3SceneSetShadowTextureFadeEnd\n");
02856 #endif
02857
02858 int val = MMpull(m);
02859 int s = MMget(m,0);
02860 if((s == NIL) || (val==NIL))
02861 {
02862 MMset(m,0,NIL);
02863 return 0;
02864 }
02865 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02866 if(scene==NULL)
02867 {
02868 MMset(m,0,NIL);
02869 return 0;
02870 }
02871 scene->O3SceneManager->setShadowTextureFadeEnd(MTOF(val));
02872 MMset(m,0,1);
02873 return 0;
02874 }
02875
02876
02886 int SO3SceneSetShadowDirLightTextureOffset(mmachine m)
02887 {
02888 #ifdef SO3_DEBUG
02889 MMechostr(MSKDEBUG,"SO3SceneSetShadowDirLightTextureOffset\n");
02890 #endif
02891
02892 int val = MMpull(m);
02893 int s = MMget(m,0);
02894 if((s == NIL) || (val==NIL))
02895 {
02896 MMset(m,0,NIL);
02897 return 0;
02898 }
02899 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02900 if(scene==NULL)
02901 {
02902 MMset(m,0,NIL);
02903 return 0;
02904 }
02905 scene->O3SceneManager->setShadowDirLightTextureOffset(MTOF(val));
02906 MMset(m,0,1);
02907 return 0;
02908 }
02909
02910
02919 int SO3SceneGetSelfShadowTexture(mmachine m)
02920 {
02921 #ifdef SO3_DEBUG
02922 MMechostr(MSKDEBUG,"SO3SceneGetSelfShadowTexture\n");
02923 #endif
02924
02925 int s = MMget(m,0);
02926 if((s == NIL) )
02927 {
02928 MMset(m,0,NIL);
02929 return 0;
02930 }
02931 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02932 if(scene==NULL)
02933 {
02934 MMset(m,0,NIL);
02935 return 0;
02936 }
02937 int val = 0;
02938
02939
02940 MMset(m,0,ITOM(val));
02941 return 0;
02942 }
02943
02944
02953 int SO3SceneGetShadowCameraSetup(mmachine m)
02954 {
02955 #ifdef SO3_DEBUG
02956 MMechostr(MSKDEBUG,"SO3SceneGetShadowCameraSetup\n");
02957 #endif
02958
02959 int s = MMget(m,0);
02960 if((s == NIL) )
02961 {
02962 MMset(m,0,NIL);
02963 return 0;
02964 }
02965 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02966 if(scene==NULL)
02967 {
02968 MMset(m,0,NIL);
02969 return 0;
02970 }
02971 int val = scene->shadowCameraSetup;
02972 MMset(m,0,ITOM(val));
02973 return 0;
02974 }
02975
02976
02985 int SO3SceneGetShadowDirectionalLightExtrusionDistance(mmachine m)
02986 {
02987 #ifdef SO3_DEBUG
02988 MMechostr(MSKDEBUG,"SO3SceneGetShadowDirectionalLightExtrusionDistance\n");
02989 #endif
02990
02991 int s = MMget(m,0);
02992 if((s == NIL) )
02993 {
02994 MMset(m,0,0);
02995 return 0;
02996 }
02997 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
02998 if(scene==NULL)
02999 {
03000 MMset(m,0,NIL);
03001 return 0;
03002 }
03003 float val = scene->O3SceneManager->getShadowDirectionalLightExtrusionDistance();
03004
03005 MMset(m,0,FTOM(val));
03006 return 0;
03007 }
03008
03009
03018 int SO3SceneGetShadowFarDistance(mmachine m)
03019 {
03020 #ifdef SO3_DEBUG
03021 MMechostr(MSKDEBUG,"SO3SceneGetShadowFarDistance\n");
03022 #endif
03023
03024 int s = MMget(m,0);
03025 if((s == NIL) )
03026 {
03027 MMset(m,0,NIL);
03028 return 0;
03029 }
03030 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03031 if(scene==NULL)
03032 {
03033 MMset(m,0,NIL);
03034 return 0;
03035 }
03036 float val = scene->O3SceneManager->getShadowFarDistance();
03037
03038 MMset(m,0,FTOM(val));
03039 return 0;
03040 }
03041
03042
03051 int SO3SceneGetShadowDirLightTextureOffset(mmachine m)
03052 {
03053 #ifdef SO3_DEBUG
03054 MMechostr(MSKDEBUG,"SO3SceneGetShadowDirLightTextureOffset\n");
03055 #endif
03056
03057 int s = MMget(m,0);
03058 if((s == NIL) )
03059 {
03060 MMset(m,0,NIL);
03061 return 0;
03062 }
03063 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03064 if(scene==NULL)
03065 {
03066 MMset(m,0,NIL);
03067 return 0;
03068 }
03069 float val = scene->O3SceneManager->getShadowDirLightTextureOffset();
03070
03071 MMset(m,0,FTOM(val));
03072 return 0;
03073 }
03074
03075
03084 int SO3SceneGetShadowTextureCount(mmachine m)
03085 {
03086 #ifdef SO3_DEBUG
03087 MMechostr(MSKDEBUG,"SO3SceneGetShadowTextureCount\n");
03088 #endif
03089
03090 int s = MMget(m,0);
03091 if((s == NIL) )
03092 {
03093 MMset(m,0,NIL);
03094 return 0;
03095 }
03096 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03097 if(scene==NULL)
03098 {
03099 MMset(m,0,NIL);
03100 return 0;
03101 }
03102 int val = (int)scene->O3SceneManager->getShadowTextureCount() ;
03103 MMset(m,0,ITOM(val));
03104 return 0;
03105 }
03106
03107
03131 int SO3SceneSetShadowTechnique(mmachine m)
03132 {
03133 #ifdef SO3_DEBUG
03134 MMechostr(MSKDEBUG,"SO3SceneSetShadowTechnique\n");
03135 #endif
03136
03137 int tec = MTOI(MMpull(m));
03138 int s = MMget(m,0);
03139 if((s == NIL) || (tec==NIL))
03140 {
03141 MMset(m,0,0);
03142 return 0;
03143 }
03144 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03145
03146
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157
03158
03159
03160
03161
03162
03163
03164
03165
03166 scene->O3SceneManager->setShadowTechnique((Ogre::ShadowTechnique)tec);
03167
03168 if(((Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_STENCIL_ADDITIVE ||(Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_STENCIL_MODULATIVE||(Ogre::ShadowTechnique)tec==SO3_SHADOWTYPE_NONE))
03169
03170 scene->O3SceneManager->setShadowTexturePixelFormat(Ogre::PF_FLOAT32_R);
03171 else
03172 scene->O3SceneManager->setShadowTexturePixelFormat(Ogre::PF_X8R8G8B8);
03173
03174 MMset(m, 0, ITOM(1));
03175 return 0;
03176 }
03177
03178
03188 int SO3SceneSetShadowCaster(mmachine m)
03189 {
03190 #ifdef SO3_DEBUG
03191 MMechostr(MSKDEBUG,"SO3SceneSetShadowCaster\n");
03192 #endif
03193
03194 int c = MMpull(m);
03195 int s = MMget(m,0);
03196 if((s == NIL) || (c==NIL))
03197 {
03198 MMset(m,0,0);
03199 return 0;
03200 }
03201
03202 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03203 try
03204 {
03205 Ogre::MaterialPtr mCaster; mCaster.setNull();
03206 mCaster = scene->O3MaterialManager->getByName(MMstartstr(m,MTOP(c)));
03207 if(mCaster.isNull())
03208 {
03209 MMset(m,0,NIL);
03210 return 0;
03211 }
03212 scene->O3SceneManager->setShadowTextureCasterMaterial (MMstartstr(m,MTOP(c)));
03213 scene->materialCaster = mCaster;
03214 }
03215 catch(Ogre::Exception &e)
03216 {
03217 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
03218 MMset(m,0,NIL);
03219 return 0;
03220 }
03221
03222 MMset(m,0,1);
03223 return 0;
03224 }
03225
03226
03236 int SO3SceneSetShadowReceiver(mmachine m)
03237 {
03238 #ifdef SO3_DEBUG
03239 MMechostr(MSKDEBUG,"SO3SceneSetShadowReceiver\n");
03240 #endif
03241
03242 int r = MMpull(m);
03243 int s = MMget(m,0);
03244 if((s == NIL) || (r==NIL))
03245 {
03246 MMset(m,0,NIL);
03247 return 0;
03248 }
03249
03250 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03251 try
03252 {
03253 Ogre::MaterialPtr mReceiver; mReceiver.setNull();
03254 mReceiver = scene->O3MaterialManager->getByName(MMstartstr(m,MTOP(r)));
03255 if(mReceiver.isNull())
03256 {
03257 MMset(m,0,NIL);
03258 return 0;
03259 }
03260 scene->O3SceneManager->setShadowTextureReceiverMaterial(MMstartstr(m,MTOP(r)));
03261 scene->materialReceiver = mReceiver;
03262
03263 }
03264 catch(Ogre::Exception &e)
03265 {
03266 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
03267 MMset(m,0,NIL);
03268 return 0;
03269 }
03270
03271 MMset(m,0,1);
03272 return 0;
03273 }
03274
03275
03284 int SO3SceneGetShadowCaster(mmachine m)
03285 {
03286 #ifdef SO3_DEBUG
03287 MMechostr(MSKDEBUG,"SO3SceneGetShadowCaster\n");
03288 #endif
03289
03290 int s = MMpull(m);
03291 if((s == NIL))
03292 {
03293 MMpush(m, NIL);
03294 return 0;
03295 }
03296 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03297 try
03298 {
03299 if(scene->materialCaster.isNull())
03300 {
03301 MMpush(m, NIL);
03302 return 0;
03303 }
03304
03305 return Mpushstrbloc(m, (char*)(scene->materialCaster->getName().c_str()));
03306 }
03307 catch(Ogre::Exception &e)
03308 {
03309 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
03310 MMpush(m, NIL);
03311 return 0;
03312 }
03313 return 0;
03314 }
03315
03316
03325 int SO3SceneGetShadowReceiver(mmachine m)
03326 {
03327 #ifdef SO3_DEBUG
03328 MMechostr(MSKDEBUG,"SO3SceneGetShadowReceiver\n");
03329 #endif
03330
03331 int s = MMpull(m);
03332 if(s == NIL)
03333 {
03334 MMpush(m, NIL);
03335 return 0;
03336 }
03337
03338 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03339 try
03340 {
03341 if(scene->materialReceiver.isNull())
03342 {
03343 MMpush(m, NIL);
03344 return 0;
03345 }
03346 return Mpushstrbloc(m, (char*)(scene->materialReceiver->getName().c_str()));
03347
03348 }
03349 catch(Ogre::Exception &e)
03350 {
03351 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
03352 MMpush(m, NIL);
03353 return 0;
03354 }
03355 return 0;
03356 }
03357
03358
03368 int SO3SceneGetNode(mmachine m)
03369 {
03370 #ifdef SO3_DEBUG
03371 MMechostr(MSKDEBUG,"SO3SceneGetNode\n");
03372 #endif
03373
03374 int name = MMpull(m);
03375 int s = MMget(m,0);
03376 if((name==NIL)||(s==NIL))
03377 {
03378 MMset(m,0,NIL);
03379 return 0;
03380 }
03381 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03382 if(scene==NULL)
03383 {
03384 MMset(m,0,NIL);
03385 return 0;
03386 }
03387 SNode* curNode;
03388 curNode = NULL;
03389 curNode = scene->GetNode(string(MMstartstr(m,MTOP(name))));
03390 if(curNode==NULL)
03391 {
03392 MMset(m,0,NIL);
03393 return 0;
03394 }
03395 int so3obj = OBJfindTH(m, SO3OBJTYPE, (int)(curNode));
03396 if(so3obj!=NIL)
03397 so3obj = MMfetch(m,so3obj,OFFOBJMAG);
03398 MMset(m,0,so3obj);
03399 return 0;
03400 }
03401
03402
03412 int SO3SceneGetObject(mmachine m)
03413 {
03414 #ifdef SO3_DEBUG
03415 MMechostr(MSKDEBUG, "SO3SceneGetObject\n");
03416 #endif
03417
03418 int name = MMpull(m);
03419 int s = MMget(m,0);
03420 if ((name==NIL)||(s==NIL))
03421 {
03422 MMset(m, 0, NIL);
03423 return 0;
03424 }
03425
03426 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03427 if (scene==NULL)
03428 {
03429 MMset(m, 0, NIL);
03430 return 0;
03431 }
03432
03433 SNode* curNode = 0;
03434 string tmpName(MMstartstr(m,MTOP(name)));
03435
03436
03437 if (tmpName == scene->GetRootNode()->GetName())
03438 curNode = scene->GetRootNode();
03439 else
03440 curNode = scene->GetNode(tmpName);
03441
03442 if (curNode==0)
03443 {
03444 MMechostr(MSKDEBUG,"Node is NULL : %s \n", tmpName.c_str());
03445 MMset(m, 0, NIL);
03446 return 0;
03447 }
03448
03449 int c = OBJfindTH(m, SO3OBJTYPE, (int)(curNode));
03450 if(c!=NIL)
03451 c = MMfetch(m, c, OFFOBJMAG);
03452
03453 MMset(m, 0, c);
03454 return 0;
03455 }
03456
03457
03467 int SO3SceneNodeCreate(mmachine m)
03468 {
03469 #ifdef SO3_DEBUG
03470 MMechostr(MSKDEBUG, "SO3SceneNodeCreate\n");
03471 #endif
03472
03473 int name = MMpull(m);
03474 int s = MMget(m, 0);
03475 if(s==NIL)
03476 {
03477 MMset(m, 0, NIL);
03478 return 0;
03479 }
03480
03481 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03482 if(scene==NULL)
03483 {
03484 MMset(m, 0, NIL);
03485 return 0;
03486 }
03487
03488
03489 std::string tmpNodeName(MMstartstr(m,MTOP(name)));
03490 SNode* node = 0;
03491 try
03492 {
03493 node = scene->CreateNode(tmpNodeName);
03494 }
03495 catch(Ogre::Exception &e)
03496 {
03497 MMechostr(MSKDEBUG,"An exception has occurred: %s\n",e.what());
03498 MMset(m,0,NIL);
03499 return 0;
03500 }
03501
03502
03503 MMpull(m);
03504 return createObject(m, node, scene);
03505 }
03506
03507
03517 int SO3SceneParseMaterialsFromGroup(mmachine m)
03518 {
03519 #ifdef SO3_DEBUG
03520 MMechostr(MSKDEBUG,"SO3SceneParseMaterialsFromGroup\n");
03521 #endif
03522
03523 int group = MMpull(m);
03524 int s = MMget(m,0);
03525 if((s==NIL))
03526 {
03527 MMset(m,0,NIL);
03528 return 0;
03529 }
03530
03531 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03532 if(scene==NULL)
03533 {
03534 MMset(m,0,NIL);
03535 return 0;
03536 }
03537
03538 const char* groupResource;
03539 if(group == NIL)
03540 groupResource = "General";
03541 else
03542 groupResource = MMstartstr(m,MTOP(group));
03543
03544 Ogre::MaterialManager::ResourceMapIterator it = scene->O3MaterialManager->getResourceIterator();
03545 int tmp_res, p = 0;
03546 while(it.hasMoreElements())
03547 {
03548 Ogre::MaterialPtr curMat = it.getNext();
03549 if(!strcmp(curMat->getGroup().c_str(),groupResource))
03550 {
03551 SMaterial* material = scene->GetMaterial(groupResource, curMat->getName().c_str());
03552 if(material!=NULL)
03553 {
03554 createOrRetrieveScolMaterialAndSendToVM(m, scene, material);
03555 INVERT(m, 0, 1);
03556 p++;
03557 }
03558 }
03559 }
03560 MMpull(m);
03561 if(MMpush(m,NIL))
03562 return MERRMEM;
03563
03564 for(int j=0;j<p;j++)
03565 {
03566 if(MMpush(m,2*2))
03567 return MERRMEM;
03568 if(int k=MBdeftab(m))
03569 return k;
03570 }
03571 return 0;
03572 }
03573
03574
03584 int SO3SceneParseNotLoadedMaterialsFromGroup(mmachine m)
03585 {
03586 #ifdef SO3_DEBUG
03587 MMechostr(MSKDEBUG,"SO3SceneParseNotLoadedMaterialsFromGroup\n");
03588 #endif
03589
03590 int group = MMpull(m);
03591 int s = MMget(m,0);
03592 if((s==NIL))
03593 {
03594 MMset(m,0,NIL);
03595 return 0;
03596 }
03597 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03598 if(scene==NULL)
03599 {
03600 MMset(m,0,NIL);
03601 return 0;
03602 }
03603 const char* groupResource;
03604 if(group == NIL)
03605 groupResource = "General";
03606 else
03607 groupResource = MMstartstr(m,MTOP(group));
03608
03609 Ogre::MaterialManager::ResourceMapIterator it = scene->O3MaterialManager->getResourceIterator();
03610
03611 int tmp_res, p = 0;
03612 if(!scene->skyBoxMat.isNull())
03613 scene->skyBoxMat->unload();
03614 if(!scene->skyDomeMat.isNull())
03615 scene->skyDomeMat->unload();
03616 if(!scene->skyPlaneMat.isNull())
03617 scene->skyPlaneMat->unload();
03618
03619 while(it.hasMoreElements())
03620 {
03621 Ogre::MaterialPtr curMat = it.getNext();
03622 if(!curMat->isLoaded())
03623 {
03624 if(!strcmp(curMat->getGroup().c_str(),groupResource))
03625 {
03626 SMaterial* material = scene->GetMaterial(groupResource, curMat->getName().c_str());
03627 if(material!=NULL)
03628 {
03629 createOrRetrieveScolMaterialAndSendToVM(m, scene, material);
03630 INVERT(m, 0, 1);
03631 p++;
03632 }
03633 }
03634 }
03635 }
03636 MMpull(m);
03637 if(MMpush(m,NIL))
03638 return MERRMEM;
03639
03640 for(int j=0;j<p;j++)
03641 {
03642 if(MMpush(m,2*2))
03643 return MERRMEM;
03644 if(int k=MBdeftab(m))
03645 return k;
03646 }
03647 return 0;
03648 }
03649
03650
03660 int SO3SceneParseCompositorsFromGroup(mmachine m)
03661 {
03662 #ifdef SO3_DEBUG
03663 MMechostr(MSKDEBUG,"SO3SceneParseCompositorsFromGroup\n");
03664 #endif
03665
03666 int group = MMpull(m);
03667 int s = MMpull(m);
03668 if((s == NIL))
03669 {
03670 MMpush(m, NIL);
03671 return 0;
03672 }
03673
03674 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
03675 if(scene==NULL)
03676 {
03677 MMpush(m, NIL);
03678 return 0;
03679 }
03680
03681 const char* groupResource;
03682 if(group == NIL)
03683 groupResource = "General";
03684 else
03685 groupResource = MMstartstr(m,MTOP(group));
03686
03687 Ogre::CompositorManager::ResourceMapIterator it = Ogre::CompositorManager::getSingleton().getResourceIterator();
03688 int p = 0;
03689 int k;
03690 std::vector<string> myStr;
03691 string currentName;
03692 while(it.hasMoreElements())
03693 {
03694 Ogre::CompositorPtr curComp = it.getNext();
03695 if(!strcmp(curComp->getGroup().c_str(), groupResource))
03696 {
03697 myStr.push_back(curComp->getName());
03698 }
03699 }
03700
03701 std::vector<string>::iterator iMyStr = myStr.begin();
03702 while (iMyStr != myStr.end())
03703 {
03704 if(k=Mpushstrbloc(m, (char*)(*iMyStr).c_str()))
03705 return k;
03706
03707 iMyStr++;
03708 }
03709
03710 if(MMpush(m,NIL))
03711 return MERRMEM;
03712
03713 for(unsigned int i=0;i<myStr.size();i++)
03714 {
03715 if(MMpush(m,2*2))
03716 return MERRMEM;
03717 if(k=MBdeftab(m))
03718 return k;
03719 }
03720 return 0;
03721 }
03722
03723
03733 int SO3SceneParseSchemeFromGroup(mmachine m)
03734 {
03735 #ifdef SO3_DEBUG
03736 MMechostr(MSKDEBUG,"SO3SceneParseSchemeFromGroup\n");
03737 #endif
03738
03739 int group = MMpull(m);
03740 int s = MMpull(m);
03741 if((s==NIL))
03742 {
03743 MMpush(m, NIL);
03744 return 0;
03745 }
03746
03747 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03748 if(scene==NULL)
03749 {
03750 MMpush(m, NIL);
03751 return 0;
03752 }
03753 const char* groupResource;
03754 if(group == NIL)
03755 groupResource = "General";
03756 else
03757 groupResource = MMstartstr(m,MTOP(group));
03758
03759 Ogre::MaterialManager::ResourceMapIterator it = scene->O3MaterialManager->getResourceIterator();
03760 int p = 0;
03761 int k;
03762 std::set<string> myStr;
03763 string currentName;
03764
03765 while(it.hasMoreElements())
03766 {
03767 Ogre::MaterialPtr curMat = it.getNext();
03768 if(!strcmp(curMat->getGroup().c_str(),groupResource))
03769 {
03770 for(int i = 0;i<curMat->getNumTechniques();i++)
03771 {
03772 std::set<string>::iterator iSchemeSearched = myStr.find(curMat->getTechnique(i)->getSchemeName());
03773 if(iSchemeSearched == myStr.end())
03774 myStr.insert(curMat->getTechnique(i)->getSchemeName());
03775 }
03776 }
03777 }
03778
03779 std::set<string>::iterator iSchemeList = myStr.begin();
03780 while (iSchemeList != myStr.end())
03781 {
03782 if(k=Mpushstrbloc(m,(char*)(*iSchemeList).c_str()))
03783 return k;
03784
03785 iSchemeList++;
03786 }
03787
03788 if(MMpush(m,NIL))
03789 return MERRMEM;
03790
03791 for(unsigned int i=0;i<myStr.size();i++)
03792 {
03793 if(MMpush(m,2*2))
03794 return MERRMEM;
03795 if(k=MBdeftab(m))
03796 return k;
03797 }
03798 return 0;
03799 }
03800
03801
03811 int SO3SceneParseParticleSystemsFromGroup(mmachine m)
03812 {
03813 #ifdef SO3_DEBUG
03814 MMechostr(MSKDEBUG,"SO3SceneParseParticleSystemsFromGroup\n");
03815 #endif
03816
03817 int group = MMpull(m);
03818 int s = MMpull(m);
03819 if((s==NIL))
03820 {
03821 MMpush(m, NIL);
03822 return 0;
03823 }
03824
03825 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03826 if(scene==NULL)
03827 {
03828 MMpush(m, NIL);
03829 return 0;
03830 }
03831
03832 const char* groupResource;
03833 if(group == NIL)
03834 groupResource = "General";
03835 else
03836 groupResource = MMstartstr(m,MTOP(group));
03837
03838 Ogre::ParticleSystemManager::ParticleSystemTemplateIterator it = scene->O3ParticleSystemManager->getTemplateIterator();
03839 int p = 0;
03840 int k;
03841 std::vector<string> myStr;
03842 string currentName;
03843 while(it.hasMoreElements())
03844 {
03845 Ogre::ParticleSystem * curPS = it.getNext();
03846 if(!strcmp(curPS->getResourceGroupName().c_str(),groupResource))
03847 {
03848 myStr.push_back(curPS->getName());
03849 }
03850 }
03851
03852 std::vector<string>::iterator iMyStr = myStr.begin();
03853 while (iMyStr != myStr.end())
03854 {
03855 if(k=Mpushstrbloc(m,(char*)(*iMyStr).c_str()))
03856 return k;
03857
03858 iMyStr++;
03859 }
03860
03861 if(MMpush(m,NIL))
03862 return MERRMEM;
03863 for(unsigned int i=0;i<myStr.size();i++)
03864 {
03865 if(MMpush(m,2*2))
03866 return MERRMEM;
03867 if(k=MBdeftab(m))
03868 return k;
03869 }
03870 return 0;
03871 }
03872
03873
03884 int SO3SceneGetMaterial(mmachine m)
03885 {
03886 #ifdef SO3_DEBUG
03887 MMechostr(MSKDEBUG,"SO3SceneGetMaterial\n");
03888 #endif
03889
03890 int name = MMpull(m);
03891 int group = MMpull(m);
03892 int s = MMget(m,0);
03893 if((name==NIL)||(s==NIL))
03894 {
03895 MMset(m,0,NIL);
03896 return 0;
03897 }
03898
03899 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03900 if(scene==NULL)
03901 {
03902 MMset(m,0,NIL);
03903 return 0;
03904 }
03905
03906 std::string groupname;
03907 if (group == NIL)
03908 groupname = "General";
03909 else
03910 groupname = MMstartstr(m,MTOP(group));
03911
03912 SMaterial* tmpMat = scene->GetMaterial(groupname, MMstartstr(m, MTOP(name)));
03913 if (tmpMat == 0)
03914 {
03915 MMset(m, 0, NIL);
03916 return 0;
03917 }
03918
03919
03920 MMpull(m);
03921 return createOrRetrieveScolMaterialAndSendToVM(m, scene, tmpMat);
03922 }
03923
03924
03935 int SO3SceneGetTexture(mmachine m)
03936 {
03937 #ifdef SO3_DEBUG
03938 MMechostr(MSKDEBUG,"SO3SceneGetTexture\n");
03939 #endif
03940
03941 int name = MMpull(m);
03942 int group = MMpull(m);
03943 int s = MMget(m,0);
03944 if((name==NIL)||(s==NIL))
03945 {
03946 MMset(m,0,NIL);
03947 return 0;
03948 }
03949 SScene* scene = (SScene*) MMfetch(m,MTOP(s),0);
03950 if(scene==NULL)
03951 {
03952 MMset(m,0,NIL);
03953 return 0;
03954 }
03955
03956
03957 MMpull(m);
03958
03959 std::string groupname;
03960 if (group == NIL)
03961 groupname = "General";
03962 else
03963 groupname = MMstartstr(m,MTOP(group));
03964
03965 STexture* texture = scene->GetTexture(groupname, MMstartstr(m, MTOP(name)));
03966 if(texture!=NULL)
03967 {
03968 int tx = OBJfindTH(m, SO3TEXTURE, (int)(texture));
03969 if(tx!=NIL)
03970 tx = MMfetch(m,tx,OFFOBJMAG);
03971 MMpush(m, tx);
03972 return 0;
03973 }
03974 else
03975 {
03976 MMechostr(MSKDEBUG,"SCOL Instance \n");
03977 std::string tmpTextureName(MMstartstr(m, MTOP(name)));
03978
03979 STexture* newTex = scene->CreateTexture(groupname, tmpTextureName, std::string(""));
03980 if(newTex==NULL)
03981 {
03982 MMpush(m, NIL);
03983 return 0;
03984 }
03985 return createTexture(m, newTex, scene);
03986 }
03987
03988 return 0;
03989 }
03990
03991
04005 int SO3PlaneCreate(mmachine m)
04006 {
04007 #ifdef SO3_DEBUG
04008 MMechostr(MSKDEBUG,"SO3PlaneCreate\n");
04009 #endif
04010
04011 int puv = MMpull(m);
04012 int pseg = MMpull(m);
04013 int psize = MMpull(m);
04014 int name = MMpull(m);
04015 int grpname = MMpull(m);
04016 int s = MMpull(m);
04017 if((name==NIL) || (s==NIL) || (psize==NIL))
04018 {
04019 MMpush(m, NIL);
04020 return 0;
04021 }
04022
04023 std::string ressouceGroup;
04024 if (grpname == NIL)
04025 ressouceGroup = "General";
04026 else
04027 ressouceGroup = MMstartstr(m, MTOP(grpname));
04028
04029 std::string planeName = MMstartstr(m, MTOP(name));
04030
04031 SScene* scene = (SScene*) MMfetch(m, MTOP(s), 0);
04032 if(scene == NULL)
04033 {
04034 MMpush(m, NIL);
04035 return 0;
04036 }
04037
04038 SPointFloat uv(1.0f, 1.0f);
04039 if (puv != NIL)
04040 {
04041 uv.x = MTOF(MMfetch(m, MTOP(puv), 0));
04042 uv.y = MTOF(MMfetch(m, MTOP(puv), 1));
04043 }
04044
04045 SPointInt seg(1, 1);
04046 if (pseg != NIL)
04047 {
04048 seg.x = MTOI(MMfetch(m, MTOP(pseg), 0));
04049 seg.y = MTOI(MMfetch(m, MTOP(pseg), 1));
04050 }
04051
04052 SPointFloat sizev;
04053 sizev.x = MTOF(MMfetch(m, MTOP(psize), 0));
04054 sizev.y = MTOF(MMfetch(m, MTOP(psize), 1));
04055
04056 SEntity* newEntity = 0;
04057 try
04058 {
04059 newEntity = scene->CreatePlane(ressouceGroup, planeName, sizev, seg, uv);
04060 }
04061 catch(Ogre::Exception &e)
04062 {
04063 MMechostr(MSKDEBUG,"An exception has occurred: %s\n", e.what());
04064 MMpush(m, NIL);
04065 return 0;
04066 }
04067
04068 return createObject(m, newEntity, scene);
04069 }
04070
04080 int SO3SceneGetAnimation(mmachine m)
04081 {
04082 #ifdef SO3_DEBUG
04083 MMechostr(MSKDEBUG, "SO3SceneGetAnimation\n");
04084 #endif
04085
04086 int name = MMpull(m);
04087 int s = MMget(m, 0);
04088 if((name==NIL)||(s==NIL))
04089 {
04090 MMset(m, 0, NIL);
04091 return 0;
04092 }
04093
04094 SScene* scene = (SScene*)MMfetch(m, MTOP(s), 0);
04095 if(scene==NULL)
04096 {
04097 MMset(m, 0, NIL);
04098 return 0;
04099 }
04100
04101 std::string animationName(MMstartstr(m, MTOP(name)));
04102 SAnim* curAnim = scene->GetAnimation(animationName);
04103 if(curAnim==0)
04104 {
04105 MMechostr(MSKDEBUG,"Animation not found!\n");
04106 MMset(m, 0, NIL);
04107 return 0;
04108 }
04109
04110 int a = OBJfindTH(m, SO3ANIM, (int)(curAnim));
04111 if(a != NIL)
04112 a = MMfetch(m, a, OFFOBJMAG);
04113
04114 MMset(m, 0, a);
04115 return 0;
04116 }
04117
04126 int SO3SceneGetAnimations(mmachine m)
04127 {
04128 #ifdef SO3_DEBUG
04129 MMechostr(MSKDEBUG,"SO3SceneGetAnimations\n");
04130 #endif
04131
04132 int s = MMpull(m);
04133 if(s == NIL)
04134 {
04135 MMpush(m, NIL);
04136 return 0;
04137 }
04138
04139 SScene* scene = (SScene*)MMfetch(m, MTOP(s), 0);
04140 if(scene==NULL)
04141 {
04142 MMpush(m, NIL);
04143 return 0;
04144 }
04145
04146 int icount = 0;
04147
04148 const SAnimMap animationListCopy = scene->GetAnimations();
04149 SAnimMap::const_iterator iAnimations = animationListCopy.begin();
04150 while (iAnimations != animationListCopy.end())
04151 {
04152 int a = OBJfindTH(m, SO3ANIM, (int)(iAnimations->second)) ;
04153
04154 if(a!=NIL)
04155 a = MMfetch(m, a, OFFOBJMAG);
04156
04157 if (MMpush(m, a))
04158 return MERRMEM;
04159
04160 iAnimations++;
04161 icount++;
04162 }
04163
04164 if(MMpush(m, NIL))
04165 return MERRMEM;
04166
04167 for(int j=0; j<icount; j++)
04168 {
04169 if (MMpush(m, 2*2))
04170 return MERRMEM;
04171
04172 if (int k=MBdeftab(m))
04173 return k;
04174 }
04175
04176 return 0;
04177 }
04178
04187 int SO3SceneGetNumAnimations(mmachine m)
04188 {
04189 #ifdef SO3_DEBUG
04190 MMechostr(MSKDEBUG, "SO3SceneGetNumAnimations\n");
04191 #endif
04192
04193 int s = MMget(m, 0);
04194 if(s == NIL)
04195 {
04196 MMset(m, 0, NIL);
04197 return 0;
04198 }
04199
04200 SScene* scene = (SScene*)MMfetch(m, MTOP(s), 0);
04201 if(scene==NULL)
04202 {
04203 MMset(m, 0, NIL);
04204 return 0;
04205 }
04206
04207 MMset(m, 0, ITOM(scene->GetNumAnimations()));
04208 return 0;
04209 }
04210
04222 int SO3CbScenePreRender(mmachine m)
04223 {
04224 #ifdef SO3_DEBUG
04225 MMechostr(MSKDEBUG,"SO3CbScenePreRender\n");
04226 #endif
04227
04228 int k = OBJaddreflex (m, SO3SCENETYPE, SO3_SCENE_PRE_RENDER_EVENT);
04229
04230 #ifdef SO3_DEBUG
04231 MMechostr(MSKDEBUG,"SO3CbScenePreRender : ok!\n");
04232 #endif
04233 return k;
04234 }
04235
04247 int SO3CbScenePostRender(mmachine m)
04248 {
04249 #ifdef SO3_DEBUG
04250 MMechostr(MSKDEBUG,"SO3CbScenePostRender\n");
04251 #endif
04252
04253 int k = OBJaddreflex (m, SO3SCENETYPE, SO3_SCENE_POST_RENDER_EVENT);
04254
04255 #ifdef SO3_DEBUG
04256 MMechostr(MSKDEBUG,"SO3CbScenePostRender : ok!\n");
04257 #endif
04258 return k;
04259 }
04260
04261 int getScenePreRenderEvent(mmachine m, WindowHandle h,unsigned msg,UINT id,LONG param,int *ret)
04262 {
04263 #ifdef SO3_DEBUG
04264 MMechostr(MSKDEBUG, "getScenePreRenderEvent\n");
04265 #endif
04266
04267 int k = 0;
04268
04269 if( !(k = OBJbeginreflex( m, SO3SCENETYPE,(int)id, SO3_SCENE_PRE_RENDER_EVENT ) ) )
04270 {
04271 MMpush(m, ITOM(static_cast<int>(param)));
04272
04273 k = OBJcallreflex(m,1);
04274 }
04275 return k;
04276 }
04277
04278 int getScenePostRenderEvent(mmachine m, WindowHandle h,unsigned msg,UINT id,LONG param,int *ret)
04279 {
04280 #ifdef SO3_DEBUG
04281 MMechostr(MSKDEBUG, "getScenePostRenderEvent\n");
04282 #endif
04283
04284 int k = 0;
04285
04286 if( !(k = OBJbeginreflex( m, SO3SCENETYPE,(int)id, SO3_SCENE_POST_RENDER_EVENT ) ) )
04287 {
04288 MMpush(m, ITOM(static_cast<int>(param)));
04289
04290 k = OBJcallreflex(m,1);
04291 }
04292 return k;
04293 }
04294
04295
04299 #define NBSCENEPKG 71
04300
04301
04305 char* SCENEname[NBSCENEPKG]=
04306 {
04307 "SO3SceneLoadEntity",
04308 "SO3SceneUnloadResource",
04309 "SO3SceneLoadResource",
04310 "SO3SceneCloneAnimation",
04311 "SO3SceneCloneAnimTrack",
04312 "SO3SceneLoadResourceMaterial",
04313 "SO3SceneCreate",
04314 "SO3SceneDelete",
04315 "SO3SceneClear",
04316 "SO3WorldSetFPS",
04317 "SO3WorldSetSize",
04318 "SO3SceneSetSkyBox",
04319 "SO3SceneSetSkyBoxEnable",
04320 "SO3SceneGetSkyBoxParameters",
04321 "SO3SceneSetSkyDome",
04322 "SO3SceneSetSkyDomeEnable",
04323 "SO3SceneGetSkyDomeParameters",
04324 "SO3SceneSetSkyPlane",
04325 "SO3SceneSetSkyPlaneEnable",
04326 "SO3SceneGetSkyPlaneParameters",
04327 "SO3SceneSetAmbientLight",
04328 "SO3SceneGetAmbientLight",
04329 "SO3SceneGetFogColor",
04330 "SO3SceneGetFogMode",
04331 "SO3SceneGetFogDensity",
04332 "SO3SceneGetFogStart",
04333 "SO3SceneGetFogEnd",
04334 "SO3SceneSetFog",
04335 "SO3SceneSetShadowColor",
04336 "SO3SceneGetShadowColor",
04337 "SO3SceneSetSelfShadowTexture",
04338 "SO3SceneSetShadowTextureCount",
04339 "SO3SceneSetShadowTextureSize",
04340 "SO3SceneSetDefaultShadowCamera",
04341 "SO3SceneSetFocusedShadowCamera",
04342 "SO3SceneSetLISPSMShadowCamera",
04343 "SO3SceneSetPlaneShadowCamera",
04344 "SO3SceneSetShadowDirectionalLightExtrusionDistance",
04345 "SO3SceneSetShadowFarDistance",
04346 "SO3SceneSetShadowTextureFadeStart",
04347 "SO3SceneGetShadowTechnique",
04348 "SO3SceneSetShadowTextureFadeEnd",
04349 "SO3SceneSetShadowDirLightTextureOffset",
04350 "SO3SceneGetSelfShadowTexture",
04351 "SO3SceneGetShadowCameraSetup",
04352 "SO3SceneGetShadowDirectionalLightExtrusionDistance",
04353 "SO3SceneGetShadowFarDistance",
04354 "SO3SceneGetShadowDirLightTextureOffset",
04355 "SO3SceneGetShadowTextureCount",
04356 "SO3SceneSetShadowTechnique",
04357 "SO3SceneSetShadowCaster",
04358 "SO3SceneSetShadowReceiver",
04359 "SO3SceneGetShadowCaster",
04360 "SO3SceneGetShadowReceiver",
04361 "SO3SceneGetNode",
04362 "SO3SceneGetObject",
04363 "SO3SceneNodeCreate",
04364 "SO3SceneParseMaterialsFromGroup",
04365 "SO3SceneParseNotLoadedMaterialsFromGroup",
04366 "SO3SceneParseCompositorsFromGroup",
04367 "SO3SceneParseSchemeFromGroup",
04368 "SO3SceneParseParticleSystemsFromGroup",
04369 "SO3SceneGetMaterial",
04370 "SO3SceneGetTexture",
04371 "SO3PlaneCreate",
04372 "SO3CbScenePreRender",
04373 "SO3CbScenePostRender",
04374 "SO3SceneCreateAnimationSequence",
04375 "SO3SceneGetAnimation",
04376 "SO3SceneGetAnimations",
04377 "SO3SceneGetNumAnimations"
04378 };
04379
04380
04384 int (*SCENEFunc[NBSCENEPKG])(mmachine m)=
04385 {
04386 SO3SceneLoadEntity,
04387 SO3SceneUnloadResource,
04388 SO3SceneLoadResource,
04389 SO3SceneCloneAnimation,
04390 SO3SceneCloneAnimTrack,
04391 SO3SceneLoadResourceMaterial,
04392 SO3SceneCreate,
04393 SO3SceneDelete,
04394 SO3SceneClear,
04395 SO3WorldSetFPS,
04396 SO3WorldSetSize,
04397 SO3SceneSetSkyBox,
04398 SO3SceneSetSkyBoxEnable,
04399 SO3SceneGetSkyBoxParameters,
04400 SO3SceneSetSkyDome,
04401 SO3SceneSetSkyDomeEnable,
04402 SO3SceneGetSkyDomeParameters,
04403 SO3SceneSetSkyPlane,
04404 SO3SceneSetSkyPlaneEnable,
04405 SO3SceneGetSkyPlaneParameters,
04406 SO3SceneSetAmbientLight,
04407 SO3SceneGetAmbientLight,
04408 SO3SceneGetFogColor,
04409 SO3SceneGetFogMode,
04410 SO3SceneGetFogDensity,
04411 SO3SceneGetFogStart,
04412 SO3SceneGetFogEnd,
04413 SO3SceneSetFog,
04414 SO3SceneSetShadowColor,
04415 SO3SceneGetShadowColor,
04416 SO3SceneSetSelfShadowTexture,
04417 SO3SceneSetShadowTextureCount,
04418 SO3SceneSetShadowTextureSize,
04419 SO3SceneSetDefaultShadowCamera,
04420 SO3SceneSetFocusedShadowCamera,
04421 SO3SceneSetLISPSMShadowCamera,
04422 SO3SceneSetPlaneShadowCamera,
04423 SO3SceneSetShadowDirectionalLightExtrusionDistance,
04424 SO3SceneSetShadowFarDistance,
04425 SO3SceneSetShadowTextureFadeStart,
04426 SO3SceneGetShadowTechnique,
04427 SO3SceneSetShadowTextureFadeEnd,
04428 SO3SceneSetShadowDirLightTextureOffset,
04429 SO3SceneGetSelfShadowTexture,
04430 SO3SceneGetShadowCameraSetup,
04431 SO3SceneGetShadowDirectionalLightExtrusionDistance,
04432 SO3SceneGetShadowFarDistance,
04433 SO3SceneGetShadowDirLightTextureOffset,
04434 SO3SceneGetShadowTextureCount,
04435 SO3SceneSetShadowTechnique,
04436 SO3SceneSetShadowCaster,
04437 SO3SceneSetShadowReceiver,
04438 SO3SceneGetShadowCaster,
04439 SO3SceneGetShadowReceiver,
04440 SO3SceneGetNode,
04441 SO3SceneGetObject,
04442 SO3SceneNodeCreate,
04443 SO3SceneParseMaterialsFromGroup,
04444 SO3SceneParseNotLoadedMaterialsFromGroup,
04445 SO3SceneParseCompositorsFromGroup,
04446 SO3SceneParseSchemeFromGroup,
04447 SO3SceneParseParticleSystemsFromGroup,
04448 SO3SceneGetMaterial,
04449 SO3SceneGetTexture,
04450 SO3PlaneCreate,
04451 SO3CbScenePreRender,
04452 SO3CbScenePostRender,
04453 SO3SceneCreateAnimationSequence,
04454 SO3SceneGetAnimation,
04455 SO3SceneGetAnimations,
04456 SO3SceneGetNumAnimations
04457 };
04458
04459
04463 int SCENEnarg[NBSCENEPKG]=
04464 {
04465 4,
04466 3,
04467 4,
04468 3,
04469 4,
04470 3,
04471 2,
04472 1,
04473 1,
04474 2,
04475 3,
04476 7,
04477 2,
04478 1,
04479 12,
04480 2,
04481 1,
04482 12,
04483 2,
04484 1,
04485 2,
04486 1,
04487 1,
04488 1,
04489 1,
04490 1,
04491 1,
04492 6,
04493 2,
04494 1,
04495 2,
04496 2,
04497 2,
04498 1,
04499 1,
04500 1,
04501 3,
04502 2,
04503 2,
04504 2,
04505 1,
04506 2,
04507 2,
04508 1,
04509 1,
04510 1,
04511 1,
04512 1,
04513 1,
04514 2,
04515 2,
04516 2,
04517 1,
04518 1,
04519 2,
04520 2,
04521 2,
04522 2,
04523 2,
04524 2,
04525 2,
04526 2,
04527 3,
04528 3,
04529 6,
04530 3,
04531 3,
04532 2,
04533 2,
04534 1,
04535 1
04536 };
04537
04538
04542 char* SCENEType[NBSCENEPKG]=
04543 {
04544 "fun [SO3_SCENE S S P] SO3_OBJECT",
04545 "fun [SO3_SCENE S I] I",
04546 "fun [SO3_SCENE S P I] I",
04547 "fun [SO3_SCENE SO3_ANIM S] SO3_ANIM",
04548 "fun [SO3_SCENE SO3_OBJECT SO3_ANIM SO3_ANIMTRACK] SO3_ANIMTRACK",
04549 "fun [SO3_SCENE S S] I",
04550 "fun [Chn S] SO3_SCENE",
04551 "fun [SO3_SCENE] I",
04552 "fun [SO3_SCENE] I",
04553 "fun [SO3_SCENE I] I",
04554 "fun [SO3_SCENE [F F F] [F F F]] I",
04555 "fun [SO3_SCENE SO3_MATERIAL F [F F F F] S I I] I",
04556 "fun [SO3_SCENE I] I",
04557 "fun [SO3_SCENE] [SO3_MATERIAL F [F F F F] I I]",
04558 "fun [SO3_SCENE SO3_MATERIAL F [F F F F] F F I I I S I I] I",
04559 "fun [SO3_SCENE I] I",
04560 "fun [SO3_SCENE] [SO3_MATERIAL F F F I I I [F F F F] I I]",
04561 "fun [SO3_SCENE SO3_MATERIAL F [F F F] F F F I I S I I] I",
04562 "fun [SO3_SCENE I] I",
04563 "fun [SO3_SCENE] [SO3_MATERIAL F F F I I F [F F F] I I]",
04564 "fun [SO3_SCENE I] I",
04565 "fun [SO3_SCENE] I",
04566 "fun [SO3_SCENE] I",
04567 "fun [SO3_SCENE] I",
04568 "fun [SO3_SCENE] F",
04569 "fun [SO3_SCENE] F",
04570 "fun [SO3_SCENE] F",
04571 "fun [SO3_SCENE I I F F F] I",
04572 "fun [SO3_SCENE I] I",
04573 "fun [SO3_SCENE] I",
04574 "fun [SO3_SCENE I] I",
04575 "fun [SO3_SCENE I] I",
04576 "fun [SO3_SCENE I] I",
04577 "fun [SO3_SCENE] I",
04578 "fun [SO3_SCENE] I",
04579 "fun [SO3_SCENE] I",
04580 "fun [SO3_SCENE [F F F] F] I",
04581 "fun [SO3_SCENE F] I",
04582 "fun [SO3_SCENE F] I",
04583 "fun [SO3_SCENE F] I",
04584 "fun [SO3_SCENE] I",
04585 "fun [SO3_SCENE F] I",
04586 "fun [SO3_SCENE F] I",
04587 "fun [SO3_SCENE] I",
04588 "fun [SO3_SCENE] I",
04589 "fun [SO3_SCENE] F",
04590 "fun [SO3_SCENE] F",
04591 "fun [SO3_SCENE] F",
04592 "fun [SO3_SCENE] I",
04593 "fun [SO3_SCENE I] I",
04594 "fun [SO3_SCENE S] I",
04595 "fun [SO3_SCENE S] I",
04596 "fun [SO3_SCENE] S",
04597 "fun [SO3_SCENE] S",
04598 "fun [SO3_SCENE S] SO3_OBJECT",
04599 "fun [SO3_SCENE S] SO3_OBJECT",
04600 "fun [SO3_SCENE S] SO3_OBJECT",
04601 "fun [SO3_SCENE S] [SO3_MATERIAL r1]",
04602 "fun [SO3_SCENE S] [SO3_MATERIAL r1]",
04603 "fun [SO3_SCENE S] [S r1]",
04604 "fun [SO3_SCENE S] [S r1]",
04605 "fun [SO3_SCENE S] [S r1]",
04606 "fun [SO3_SCENE S S] SO3_MATERIAL",
04607 "fun [SO3_SCENE S S] SO3_TEXTURE",
04608 "fun [SO3_SCENE S S [F F] [I I] [F F]] SO3_OBJECT",
04609 "fun [SO3_SCENE fun [SO3_SCENE u0 I] u1 u0] SO3_SCENE",
04610 "fun [SO3_SCENE fun [SO3_SCENE u0 I] u1 u0] SO3_SCENE",
04611 "fun [SO3_SCENE S] SO3_ANIM",
04612 "fun [SO3_SCENE S] SO3_ANIM",
04613 "fun [SO3_SCENE] [SO3_ANIM r1]",
04614 "fun [SO3_SCENE] I"
04615 };
04616
04617
04623 int SCOLloadScene(mmachine m,cbmachine w)
04624 {
04625 SCENE_PRE_RENDER_EVENT = OBJgetUserEvent();
04626 OBJdefEvent( SCENE_PRE_RENDER_EVENT, (int (__cdecl *)(struct Mmachine *,int,unsigned int,int,int,int *))getScenePreRenderEvent );
04627 SCENE_POST_RENDER_EVENT = OBJgetUserEvent();
04628 OBJdefEvent( SCENE_POST_RENDER_EVENT, (int (__cdecl *)(struct Mmachine *,int,unsigned int,int,int,int *))getScenePostRenderEvent );
04629
04630 return PKhardpak( m, "Scene", NBSCENEPKG, SCENEname, SCENEFunc, SCENEnarg, SCENEType );
04631 }
