Project

General

Profile

SO3Engine
SCOLLight.cpp
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OpenSpace3D
4 For the latest info, see http://www.openspace3d.com
5 
6 Copyright (c) 2012 I-maginer
7 
8 This program is free software; you can redistribute it and/or modify it under
9 the terms of the GNU Lesser General Public License as published by the Free Software
10 Foundation; either version 2 of the License, or (at your option) any later
11 version.
12 
13 This program is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
16 
17 You should have received a copy of the GNU Lesser General Public License along with
18 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
20 http://www.gnu.org/copyleft/lesser.txt
21 
22 -----------------------------------------------------------------------------
23 */
24 
25 
33 #include "SCOLPack/SO3SCOL.h"
35 
36 // Scene Graph includes
37 #include "SO3SceneGraph/SO3Light.h"
38 #include "SO3SceneGraph/SO3Scene.h"
39 
49 int SO3LightCreate(mmachine m)
50 {
51 #ifdef SO3_DEBUG
52  MMechostr(MSKDEBUG, "SO3LightCreate\n");
53 #endif
54 
55  int name = MMpull(m);
56  int s = MMget(m, 0);
57  if (s==NIL)
58  {
59  MMset(m, 0, NIL);
60  return 0;
61  }
62 
63  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
64  if (scene==NULL)
65  {
66  MMset(m, 0, NIL);
67  return 0;
68  }
69 
70  // Create Node
71  std::string tmpLightName(MMstartstr(m,MTOP(name)));
72  SLight* light = 0;
73 
74  try
75  {
76  light = scene->CreateLight(tmpLightName);
77  }
78  catch(Ogre::Exception &e)
79  {
80  MMechostr(MSKDEBUG,"An exception has occurred : %s\n",e.what());
81  MMset(m, 0, NIL);
82  return 0;
83  }
84 
85  // remove last param
86  MMpull(m);
87  return createObject(m, light, scene);
88 }
89 
90 
105 int SO3LightSetType(mmachine m)
106 {
107 #ifdef SO3_DEBUG
108  MMechostr(MSKDEBUG, "SO3LightSetType\n");
109 #endif
110 
111  int type = MMpull(m);
112  int l = MMget(m, 0);
113  if ((type==NIL)||(l==NIL))
114  {
115  MMechostr(MSKDEBUG, "l==NIL\n");
116  MMset(m, 0, NIL);
117  return 0;
118  }
119 
120  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
121  if(node == 0)
122  {
123  MMset(m, 0, NIL);
124  return 0;
125  }
126 
127  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
128  {
129  MMset(m, 0, NIL);
130  return 0;
131  }
132 
133  SLight* light = static_cast<SLight*>(node);
134 
135  light->SetType(static_cast <SLight::LightType> (MTOI(type)));
136 
137  MMset(m, 0, ITOM(1));
138 
139  return 0;
140 }
141 
142 
156 int SO3LightGetType(mmachine m)
157 {
158 #ifdef SO3_DEBUG
159  MMechostr(MSKDEBUG, "SO3LightGetType\n");
160 #endif
161 
162  int l = MMget(m, 0);
163  if(l==NIL)
164  {
165  MMechostr(MSKDEBUG, "l==NIL\n");
166  MMset(m, 0, NIL);
167  return 0;
168  }
169 
170  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
171  if(node == 0)
172  {
173  MMset(m, 0, NIL);
174  return 0;
175  }
176 
177  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
178  {
179  MMset(m, 0, NIL);
180  return 0;
181  }
182 
183  SLight* light = static_cast<SLight*>(node);
184 
185  int type = static_cast <int> (light->GetType());
186  MMset(m, 0, ITOM(type));
187  return 0;
188 }
189 
190 
200 int SO3LightSetDiffuseColor(mmachine m)
201 {
202 #ifdef SO3_DEBUG
203  MMechostr(MSKDEBUG, "SO3LightSetDiffuseColor\n");
204 #endif
205 
206  int diffuse = MMpull(m);
207  int l = MMget(m, 0);
208  if ((l==NIL)||(diffuse==NIL))
209  {
210  MMset(m, 0, NIL);
211  return 0;
212  }
213 
214  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
215  if(node == 0)
216  {
217  MMset(m, 0, NIL);
218  return 0;
219  }
220 
221  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
222  {
223  MMset(m, 0, NIL);
224  return 0;
225  }
226 
227  SLight* light = static_cast<SLight*>(node);
228 
229  light->SetDiffuseColour(MTOI(diffuse));
230  MMset(m, 0, ITOM(1));
231 
232  return 0;
233 }
234 
243 int SO3LightGetDiffuseColor(mmachine m)
244 {
245 #ifdef SO3_DEBUG
246  MMechostr(MSKDEBUG, "SO3LightGetDiffuseColor\n");
247 #endif
248 
249  int l = MMget(m, 0);
250  if (l==NIL)
251  {
252  MMset(m, 0, NIL);
253  return 0;
254  }
255 
256  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
257  if(node == 0)
258  {
259  MMset(m, 0, NIL);
260  return 0;
261  }
262 
263  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
264  {
265  MMset(m, 0, NIL);
266  return 0;
267  }
268 
269  SLight* light = static_cast<SLight*>(node);
270  int val = light->GetDiffuseColour();
271  MMset(m, 0, ITOM(val));
272  return 0;
273 }
274 
275 
285 int SO3LightSetPowerScale(mmachine m)
286 {
287 #ifdef SO3_DEBUG
288  MMechostr(MSKDEBUG, "SO3LightSetPowerScale\n");
289 #endif
290 
291  int pow = MMpull(m);
292  int l = MMget(m, 0);
293  if ((l==NIL)||(pow==NIL))
294  {
295  MMset(m, 0, NIL);
296  return 0;
297  }
298 
299  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
300  if(node == 0)
301  {
302  MMset(m, 0, NIL);
303  return 0;
304  }
305 
306  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
307  {
308  MMset(m, 0, NIL);
309  return 0;
310  }
311 
312  SLight* light = static_cast<SLight*>(node);
313 
314  light->SetPowerScale(MTOF(pow));
315  MMset(m, 0, ITOM(1));
316 
317  return 0;
318 }
319 
320 
331 {
332 #ifdef SO3_DEBUG
333  MMechostr(MSKDEBUG, "SO3LightSetShadowFarDistance\n");
334 #endif
335 
336  int d = MMpull(m);
337  int l = MMget(m, 0);
338  if ((l==NIL)||(d==NIL))
339  {
340  MMset(m, 0, NIL);
341  return 0;
342  }
343 
344  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
345  if(node == 0)
346  {
347  MMset(m, 0, NIL);
348  return 0;
349  }
350 
351  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
352  {
353  MMset(m, 0, NIL);
354  return 0;
355  }
356 
357  SLight* light = static_cast<SLight*>(node);
358 
359  light->SetShadowFarDistance(MTOF(d));
360  MMset(m, 0, ITOM(1));
361 
362  return 0;
363 }
364 
365 
374 int SO3LightGetPowerScale(mmachine m)
375 {
376 #ifdef SO3_DEBUG
377  MMechostr(MSKDEBUG, "SO3LightGetPowerScale\n");
378 #endif
379 
380  int l = MMget(m, 0);
381  if (l==NIL)
382  {
383  MMset(m, 0, NIL);
384  return 0;
385  }
386 
387  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
388  if(node == 0)
389  {
390  MMset(m, 0, NIL);
391  return 0;
392  }
393 
394  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
395  {
396  MMset(m, 0, NIL);
397  return 0;
398  }
399 
400  SLight* light = static_cast<SLight*>(node);
401 
402  float pow = light->GetPowerScale();
403  MMset(m, 0, FTOM(pow));
404 
405  return 0;
406 }
407 
408 
418 {
419 #ifdef SO3_DEBUG
420  MMechostr(MSKDEBUG, "SO3LightGetShadowFarDistance\n");
421 #endif
422 
423  int l = MMget(m, 0);
424  if (l==NIL)
425  {
426  MMset(m, 0, NIL);
427  return 0;
428  }
429 
430  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
431  if(node == 0)
432  {
433  MMset(m, 0, NIL);
434  return 0;
435  }
436 
437  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
438  {
439  MMset(m, 0, NIL);
440  return 0;
441  }
442 
443  SLight* light = static_cast<SLight*>(node);
444 
445  float d = light->GetShadowFarDistance();
446  MMset(m, 0, FTOM(d));
447 
448  return 0;
449 }
450 
451 
461 int SO3LightSetVisible(mmachine m)
462 {
463 #ifdef SO3_DEBUG
464  MMechostr(MSKDEBUG, "SO3LightSetVisible\n");
465 #endif
466 
467  int v = MTOI(MMpull(m));
468  int l = MMget(m, 0);
469  if (l==NIL)
470  {
471  MMset(m, 0, 0);
472  return 0;
473  }
474 
475  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
476  if(node == 0)
477  {
478  MMset(m, 0, NIL);
479  return 0;
480  }
481 
482  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
483  {
484  MMset(m, 0, NIL);
485  return 0;
486  }
487 
488  SLight* light = static_cast<SLight*>(node);
489 
490  if (v==0)
491  light->SetVisible(false);
492  else
493  light->SetVisible(true);
494 
495  MMset(m, 0, ITOM(1));
496  return 0;
497 }
498 
499 
508 int SO3LightGetVisible(mmachine m)
509 {
510 #ifdef SO3_DEBUG
511  MMechostr(MSKDEBUG, "SO3LightGetVisible\n");
512 #endif
513 
514  int l = MMget(m, 0);
515  if (l==NIL)
516  {
517  MMset(m, 0, NIL);
518  return 0;
519  }
520 
521  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
522  if(node == 0)
523  {
524  MMset(m, 0, NIL);
525  return 0;
526  }
527 
528  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
529  {
530  MMset(m, 0, NIL);
531  return 0;
532  }
533 
534  SLight* light = static_cast<SLight*>(node);
535 
536  int val = 0;
537 
538  if (light->GetVisible())
539  val = 1;
540 
541  MMset(m, 0, ITOM(val));
542 
543  return 0;
544 }
545 
546 
556 int SO3LightSetVolumetric(mmachine m)
557 {
558 #ifdef SO3_DEBUG
559  MMechostr(MSKDEBUG, "SO3LightSetVolumetric\n");
560 #endif
561 
562  int v = MTOI(MMpull(m));
563  int l = MMget(m, 0);
564  if (l==NIL)
565  {
566  MMset(m, 0, 0);
567  return 0;
568  }
569 
570  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
571  if(node == 0)
572  {
573  MMset(m, 0, NIL);
574  return 0;
575  }
576 
577  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
578  {
579  MMset(m, 0, NIL);
580  return 0;
581  }
582 
583  SLight* light = static_cast<SLight*>(node);
584 
585  if (v==0)
586  light->SetVolumetric(false);
587  else
588  light->SetVolumetric(true);
589 
590  MMset(m, 0, ITOM(1));
591  return 0;
592 }
593 
594 
603 int SO3LightGetVolumetric(mmachine m)
604 {
605 #ifdef SO3_DEBUG
606  MMechostr(MSKDEBUG, "SO3LightGetVolumetric\n");
607 #endif
608 
609  int l = MMget(m, 0);
610  if (l==NIL)
611  {
612  MMset(m, 0, NIL);
613  return 0;
614  }
615 
616  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
617  if(node == 0)
618  {
619  MMset(m, 0, NIL);
620  return 0;
621  }
622 
623  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
624  {
625  MMset(m, 0, NIL);
626  return 0;
627  }
628 
629  SLight* light = static_cast<SLight*>(node);
630 
631  int val = 0;
632 
633  if (light->GetVolumetric())
634  val = 1;
635 
636  MMset(m, 0, ITOM(val));
637 
638  return 0;
639 }
640 
641 
651 int SO3LightSetAttenuation(mmachine m)
652 {
653 #ifdef SO3_DEBUG
654  MMechostr(MSKDEBUG, "SO3LightSetAttenuation\n");
655 #endif
656 
657  int param = MMpull(m);
658  int l = MMget(m, 0);
659  if ((l==NIL)||(param==NIL))
660  {
661  MMset(m, 0, NIL);
662  return 0;
663  }
664 
665  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
666  if(node == 0)
667  {
668  MMset(m, 0, NIL);
669  return 0;
670  }
671 
672  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
673  {
674  MMset(m, 0, NIL);
675  return 0;
676  }
677 
678  SLight* light = static_cast<SLight*>(node);
679 
680  light->SetAttenuation(MTOF(MMfetch(m, MTOI(param), 0)),
681  MTOF(MMfetch(m, MTOI(param), 1)),
682  MTOF(MMfetch(m, MTOI(param), 2)),
683  MTOF(MMfetch(m, MTOI(param), 3)));
684 
685  MMset(m, 0, ITOM(1));
686  return 0;
687 }
688 
689 
700 {
701 #ifdef SO3_DEBUG
702  MMechostr(MSKDEBUG, "SO3LightSetAttenuationAuto\n");
703 #endif
704 
705  int irange = MMpull(m);
706  int l = MMget(m, 0);
707  if ((irange == NIL) || (l == NIL))
708  {
709  MMset(m, 0, NIL);
710  return 0;
711  }
712 
713  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
714  if(node == 0)
715  {
716  MMset(m, 0, NIL);
717  return 0;
718  }
719 
720  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
721  {
722  MMset(m, 0, NIL);
723  return 0;
724  }
725 
726  SLight* light = static_cast<SLight*>(node);
727  light->SetAttenuation(MTOF(irange));
728  MMset(m, 0, ITOM(1));
729  return 0;
730 }
731 
732 
733 
742 int SO3LightGetAttenuation(mmachine m)
743 {
744 #ifdef SO3_DEBUG
745  MMechostr(MSKDEBUG, "SO3LightGetAttenuation\n");
746 #endif
747 
748  int l = MMget(m, 0);
749  if (l==NIL)
750  {
751  MMset(m, 0, NIL);
752  return 0;
753  }
754 
755  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
756  if(node == 0)
757  {
758  MMset(m, 0, NIL);
759  return 0;
760  }
761 
762  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
763  {
764  MMset(m, 0, NIL);
765  return 0;
766  }
767 
768  SLight* light = static_cast<SLight*>(node);
769 
770  Ogre::Vector4 attenuation = light->GetAttenuation();
771 
772  int tuple = MMmalloc(m, 4, TYPETAB);
773  if (tuple==NIL)
774  {
775  MMset(m, 0, NIL);
776  return MERRMEM;
777  }
778 
779  MMstore(m, tuple, 0, FTOM(attenuation.x));
780  MMstore(m, tuple, 1, FTOM(attenuation.y));
781  MMstore(m, tuple, 2, FTOM(attenuation.z));
782  MMstore(m, tuple, 3, FTOM(attenuation.w));
783  MMset(m, 0, PTOM(tuple));
784 
785  return 0;
786 }
787 
788 
799 {
800 #ifdef SO3_DEBUG
801  MMechostr(MSKDEBUG, "SO3LightSetSpecularColor\n");
802 #endif
803 
804  int specular = MMpull(m);
805  int l = MMget(m, 0);
806  if ((l==NIL)||(specular==NIL))
807  {
808  MMset(m, 0, NIL);
809  return 0;
810  }
811 
812  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
813  if(node == 0)
814  {
815  MMset(m, 0, NIL);
816  return 0;
817  }
818 
819  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
820  {
821  MMset(m, 0, NIL);
822  return 0;
823  }
824 
825  SLight* light = static_cast<SLight*>(node);
826 
827  light->SetSpecularColour(MTOI(specular));
828 
829  MMset(m, 0, ITOM(1));
830 
831  return 0;
832 }
833 
834 
844 {
845 #ifdef SO3_DEBUG
846  MMechostr(MSKDEBUG, "SO3LightGetSpecularColor\n");
847 #endif
848 
849  int l = MMget(m, 0);
850  if (l==NIL)
851  {
852  MMset(m, 0, NIL);
853  return 0;
854  }
855 
856  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
857  if(node == 0)
858  {
859  MMset(m, 0, NIL);
860  return 0;
861  }
862 
863  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
864  {
865  MMset(m, 0, NIL);
866  return 0;
867  }
868 
869  SLight* light = static_cast<SLight*>(node);
870 
871  int val = light->GetSpecularColour();
872  MMset(m, 0, ITOM(val));
873 
874  return 0;
875 }
876 
877 
887 int SO3LightSetSpotFallOff(mmachine m)
888 {
889 #ifdef SO3_DEBUG
890  MMechostr(MSKDEBUG, "SO3LightSetSpotFallOff\n");
891 #endif
892 
893  int fal = MMpull(m);
894  int l = MMget(m, 0);
895  if ((l==NIL)||(fal==NIL))
896  {
897  MMset(m, 0, NIL);
898  return 0;
899  }
900 
901  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
902  if(node == 0)
903  {
904  MMset(m, 0, NIL);
905  return 0;
906  }
907 
908  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
909  {
910  MMset(m, 0, NIL);
911  return 0;
912  }
913 
914  SLight* light = static_cast<SLight*>(node);
915 
916  light->SetSpotlightFalloff(MTOF(fal));
917  MMset(m, 0, ITOM(1));
918 
919  return 0;
920 }
921 
922 
931 int SO3LightGetSpotFallOff(mmachine m)
932 {
933 #ifdef SO3_DEBUG
934  MMechostr(MSKDEBUG, "SO3LightGetSpotFallOff\n");
935 #endif
936 
937  int l = MMget(m, 0);
938  if (l==NIL)
939  {
940  MMset(m, 0, NIL);
941  return 0;
942  }
943 
944  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
945  if(node == 0)
946  {
947  MMset(m, 0, NIL);
948  return 0;
949  }
950 
951  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
952  {
953  MMset(m, 0, NIL);
954  return 0;
955  }
956 
957  SLight* light = static_cast<SLight*>(node);
958 
959  float f = light->GetSpotlightFalloff();
960  MMset(m, 0, FTOM(f));
961 
962  return 0;
963 }
964 
965 
976 {
977 #ifdef SO3_DEBUG
978  MMechostr(MSKDEBUG, "SO3LightSetSpotInnerAngle\n");
979 #endif
980 
981  int ang = MMpull(m);
982  int l = MMget(m, 0);
983  if ((l==NIL)||(ang==NIL))
984  {
985  MMset(m, 0, NIL);
986  return 0;
987  }
988 
989  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
990  if(node == 0)
991  {
992  MMset(m, 0, NIL);
993  return 0;
994  }
995 
996  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
997  {
998  MMset(m, 0, NIL);
999  return 0;
1000  }
1001 
1002  SLight* light = static_cast<SLight*>(node);
1003 
1004  light->SetSpotlightInnerAngle(MTOF(ang));
1005 
1006  MMset(m, 0, ITOM(1));
1007 
1008  return 0;
1009 }
1010 
1011 
1022 {
1023 #ifdef SO3_DEBUG
1024  MMechostr(MSKDEBUG, "SO3LightSetSpotOuterAngle\n");
1025 #endif
1026 
1027  int ang = MMpull(m);
1028  int l = MMget(m, 0);
1029  if ((l==NIL)||(ang==NIL))
1030  {
1031  MMset(m, 0, NIL);
1032  return 0;
1033  }
1034 
1035  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
1036  if(node == 0)
1037  {
1038  MMset(m, 0, NIL);
1039  return 0;
1040  }
1041 
1042  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
1043  {
1044  MMset(m, 0, NIL);
1045  return 0;
1046  }
1047 
1048  SLight* light = static_cast<SLight*>(node);
1049 
1050  light->SetSpotlightOuterAngle(MTOF(ang));
1051 
1052  MMset(m, 0, ITOM(1));
1053 
1054  return 0;
1055 }
1056 
1057 
1067 int SO3LightSetSpotRange(mmachine m)
1068 {
1069 #ifdef SO3_DEBUG
1070  MMechostr(MSKDEBUG, "SO3LightSetSpotRange\n");
1071 #endif
1072 
1073  int param = MMpull(m);
1074  int l = MMget(m, 0);
1075  if ((l==NIL)||(param==NIL))
1076  {
1077  MMset(m, 0, NIL);
1078  return 0;
1079  }
1080 
1081  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
1082  if(node == 0)
1083  {
1084  MMset(m, 0, NIL);
1085  return 0;
1086  }
1087 
1088  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
1089  {
1090  MMset(m, 0, NIL);
1091  return 0;
1092  }
1093 
1094  SLight* light = static_cast<SLight*>(node);
1095 
1096  if((MMfetch(m,MTOP(param),0)==NIL) || (MMfetch(m,MTOP(param),1)==NIL) || (MMfetch(m,MTOP(param),2)==NIL))
1097  {
1098  MMset(m, 0, NIL);
1099  return 0;
1100  }
1101 
1102  light->SetSpotlightInnerAngle(MTOF(MMfetch(m, MTOP(param), 0)));
1103  light->SetSpotlightOuterAngle(MTOF(MMfetch(m, MTOP(param), 1)));
1104  light->SetSpotlightFalloff(MTOF(MMfetch(m, MTOP(param), 2)));
1105 
1106  MMset(m, 0, ITOM(1));
1107 
1108  return 0;
1109 }
1110 
1111 
1121 {
1122 #ifdef SO3_DEBUG
1123  MMechostr(MSKDEBUG, "SO3LightGetSpotInnerAngle\n");
1124 #endif
1125 
1126  int l = MMget(m, 0);
1127  if (l==NIL)
1128  {
1129  MMset(m, 0, NIL);
1130  return 0;
1131  }
1132 
1133  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
1134  if(node == 0)
1135  {
1136  MMset(m, 0, NIL);
1137  return 0;
1138  }
1139 
1140  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
1141  {
1142  MMset(m, 0, NIL);
1143  return 0;
1144  }
1145 
1146  SLight* light = static_cast<SLight*>(node);
1147 
1148  float inner = light->GetSpotlightInnerAngle();
1149  MMset(m, 0, FTOM(inner));
1150 
1151  return 0;
1152 }
1153 
1154 
1164 {
1165 #ifdef SO3_DEBUG
1166  MMechostr(MSKDEBUG, "SO3LightGetSpotOuterAngle\n");
1167 #endif
1168 
1169  int l = MMget(m, 0);
1170  if (l==NIL)
1171  {
1172  MMset(m, 0, NIL);
1173  return 0;
1174  }
1175 
1176  SNode* node = MMgetPointer<SNode*>(m, MTOP(l));
1177  if(node == 0)
1178  {
1179  MMset(m, 0, NIL);
1180  return 0;
1181  }
1182 
1183  if (node->GetNodeType() != SNode::LIGHT_TYPE_ID)
1184  {
1185  MMset(m, 0, NIL);
1186  return 0;
1187  }
1188 
1189  SLight* light = static_cast<SLight*>(node);
1190 
1191  float f = light->GetSpotlightOuterAngle();
1192  MMset(m, 0, FTOM(f));
1193 
1194  return 0;
1195 }
1196 
1197 
1198 NativeDefinition natSO3Light[] = {
1199  { "SO3LightCreate", 2, "fun [SO3_SCENE S] SO3_OBJECT", SO3LightCreate },
1200  { "SO3LightSetType", 2, "fun [SO3_OBJECT I] I", SO3LightSetType },
1201  { "SO3LightGetType", 1, "fun [SO3_OBJECT] I", SO3LightGetType },
1202  { "SO3LightSetDiffuseColor", 2, "fun [SO3_OBJECT I] I", SO3LightSetDiffuseColor },
1203  { "SO3LightGetDiffuseColor", 1, "fun [SO3_OBJECT] I", SO3LightGetDiffuseColor },
1204  { "SO3LightSetPowerScale", 2, "fun [SO3_OBJECT F] I", SO3LightSetPowerScale },
1205  { "SO3LightSetShadowFarDistance", 2, "fun [SO3_OBJECT F] I", SO3LightSetShadowFarDistance },
1206  { "SO3LightGetPowerScale", 1, "fun [SO3_OBJECT] F", SO3LightGetPowerScale },
1207  { "SO3LightGetShadowFarDistance", 1, "fun [SO3_OBJECT] F", SO3LightGetShadowFarDistance },
1208  { "SO3LightSetVisible", 2, "fun [SO3_OBJECT I] I", SO3LightSetVisible },
1209  { "SO3LightGetVisible", 1, "fun [SO3_OBJECT] I", SO3LightGetVisible },
1210  { "SO3LightSetAttenuation", 2, "fun [SO3_OBJECT [F F F F]] I", SO3LightSetAttenuation },
1211  { "SO3LightSetAttenuationAuto", 2, "fun [SO3_OBJECT F] I", SO3LightSetAttenuationAuto },
1212  { "SO3LightGetAttenuation", 1, "fun [SO3_OBJECT] [F F F F]", SO3LightGetAttenuation },
1213  { "SO3LightSetSpecularColor", 2, "fun [SO3_OBJECT I] I", SO3LightSetSpecularColor },
1214  { "SO3LightGetSpecularColor", 1, "fun [SO3_OBJECT] I", SO3LightGetSpecularColor },
1215  { "SO3LightSetSpotFallOff", 2, "fun [SO3_OBJECT F] I", SO3LightSetSpotFallOff },
1216  { "SO3LightGetSpotFallOff", 1, "fun [SO3_OBJECT] F", SO3LightGetSpotFallOff },
1217  { "SO3LightSetSpotInnerAngle", 2, "fun [SO3_OBJECT F] I", SO3LightSetSpotInnerAngle },
1218  { "SO3LightSetSpotOuterAngle", 2, "fun [SO3_OBJECT F] I", SO3LightSetSpotOuterAngle },
1219  { "SO3LightGetSpotInnerAngle", 1, "fun [SO3_OBJECT] F", SO3LightGetSpotInnerAngle },
1220  { "SO3LightGetSpotOuterAngle", 1, "fun [SO3_OBJECT] F", SO3LightGetSpotOuterAngle },
1221  { "SO3LightSetSpotRange", 2, "fun [SO3_OBJECT [F F F]] I", SO3LightSetSpotRange },
1222  { "SO3LightSetVolumetric", 2, "fun [SO3_OBJECT I] I", SO3LightSetVolumetric },
1223  { "SO3LightGetVolumetric", 1, "fun [SO3_OBJECT] I", SO3LightGetVolumetric }
1224 };
1225 
1226 
1232 int SCOLloadLight(mmachine m,cbmachine w)
1233 {
1234  return PKhardpak2(m, "SO3Light.pkg", sizeof(natSO3Light) / sizeof(natSO3Light[0]), natSO3Light);
1235 }
1236 
1237 
1243 {
1244  return 0;
1245 }
int SO3LightGetSpotInnerAngle(mmachine m)
SO3LightGetSpotInnerAngle : Get the spot inner angle of a spot light.
Definition: SCOLLight.cpp:1120
int SO3LightSetVisible(mmachine m)
SO3LightSetVisible : defines visibility state of a light.
Definition: SCOLLight.cpp:461
int SCOLloadLight(mmachine m, cbmachine w)
Load the SO3Engine Lights function.
Definition: SCOLLight.cpp:1232
int SO3LightSetDiffuseColor(mmachine m)
SO3LightSetDiffuseColor : defines diffuse color of a light.
Definition: SCOLLight.cpp:200
int SO3LightGetSpotOuterAngle(mmachine m)
SO3LightGetSpotOuterAngle : Get the spot outer angle of a spot light.
Definition: SCOLLight.cpp:1163
int SO3LightSetSpotInnerAngle(mmachine m)
SO3LightSetSpotInnerAngle : defines spot inner angle of a spot light.
Definition: SCOLLight.cpp:975
int SO3LightGetAttenuation(mmachine m)
SO3LightGetAttenuation : Get the attenuation coefficients for a light.
Definition: SCOLLight.cpp:742
NativeDefinition natSO3Light[]
Definition: SCOLLight.cpp:1198
int SCOLfreeLight()
free the SO3Engine Lights function
Definition: SCOLLight.cpp:1242
int SO3LightGetSpotFallOff(mmachine m)
SO3LightGetSpotFallOff : Get the spot fall off of a spot light.
Definition: SCOLLight.cpp:931
int SO3LightGetVisible(mmachine m)
SO3LightGetVisible : Get the visibility state of a light.
Definition: SCOLLight.cpp:508
SCOL_EXPORT void SCOL_PTR_TYPE param
Definition: SO3SCOL.cpp:4744
int SO3LightGetType(mmachine m)
SO3LightGetType : Returns the type of light.
Definition: SCOLLight.cpp:156
int SO3LightGetVolumetric(mmachine m)
SO3LightGetVolumetric : Get the volumetric state of a light.
Definition: SCOLLight.cpp:603
int SO3LightGetSpecularColor(mmachine m)
SO3LightGetSpecularColor : Get the specular color of a light.
Definition: SCOLLight.cpp:843
int createObject(mmachine m, SNode *curNode, SScene *curScene)
int SO3LightSetSpotOuterAngle(mmachine m)
SO3LightSetSpotOuterAngle : defines spot outer angle of a spot light.
Definition: SCOLLight.cpp:1021
int SO3LightSetPowerScale(mmachine m)
SO3LightSetPowerScale : defines power scale of a light.
Definition: SCOLLight.cpp:285
int SO3LightSetVolumetric(mmachine m)
SO3LightSetVolumetric : defines if a light is displayed as a volumetric light.
Definition: SCOLLight.cpp:556
int SO3LightGetDiffuseColor(mmachine m)
SO3LightGetDiffuseColor : Get the diffuse color of a light.
Definition: SCOLLight.cpp:243
int SO3LightSetSpecularColor(mmachine m)
SO3LightSetSpecularColor : defines specular color of a light.
Definition: SCOLLight.cpp:798
SCOL_EXPORT int cbmachine w
Definition: SO3SCOL.cpp:4823
int SO3LightGetPowerScale(mmachine m)
SO3LightGetPowerScale : Get the power scale of a light.
Definition: SCOLLight.cpp:374
int SO3LightSetAttenuationAuto(mmachine m)
SO3LightSetAttenuationAuto : defines attenuation coefficients for a light automatically, from given range.
Definition: SCOLLight.cpp:699
int SO3LightSetSpotFallOff(mmachine m)
SO3LightSetSpotFallOff : defines spot fall off of a spot light.
Definition: SCOLLight.cpp:887
int SO3LightGetShadowFarDistance(mmachine m)
SO3LightGetShadowFarDistance : Get the shadow far distance of a light.
Definition: SCOLLight.cpp:417
int SO3LightSetAttenuation(mmachine m)
SO3LightSetAttenuation : defines attenuation coefficients for a light.
Definition: SCOLLight.cpp:651
int SO3LightSetShadowFarDistance(mmachine m)
SO3LightSetShadowFarDistance : defines shadows far distance of a light.
Definition: SCOLLight.cpp:330
int SO3LightSetSpotRange(mmachine m)
SO3LightSetSpotRange : defines spot range of a spot light.
Definition: SCOLLight.cpp:1067
MMechostr(MSKDEBUG, " > Start loading Plugin SO3Engine dll\)
int SO3LightSetType(mmachine m)
SO3LightSetType : Defines the type of light.
Definition: SCOLLight.cpp:105
int SO3LightCreate(mmachine m)
main include
Definition: SCOLLight.cpp:49