Project

General

Profile

SO3Engine
SCOLFlashControl.cpp
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OpenSpace3D
4For the latest info, see http://www.openspace3d.com
5
6Copyright (c) 2012 I-maginer
7
8This program is free software; you can redistribute it and/or modify it under
9the terms of the GNU Lesser General Public License as published by the Free Software
10Foundation; either version 2 of the License, or (at your option) any later
11version.
12
13This program is distributed in the hope that it will be useful, but WITHOUT
14ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
15FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
16
17You should have received a copy of the GNU Lesser General Public License along with
18this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19Place - Suite 330, Boston, MA 02111-1307, USA, or go to
20http://www.gnu.org/copyleft/lesser.txt
21
22-----------------------------------------------------------------------------
23*/
24
25
34#include "SCOLPack/SO3SCOL.h"
35
36// Renderer includes
37#ifdef SO3_FLASH_ENABLE
38# include "SO3Renderer/SO3FlashWidget.h"
39#endif
40
41#include "SO3Renderer/SO3Root.h"
42#include "SO3Renderer/SO3WidgetManager.h"
43#include "SO3Material/SO3Material.h"
44
45// Scene Graph includes
46#include "SO3SceneGraph/SO3Scene.h"
47
69int SO3FlashControlCreate(mmachine m)
70{
71#ifdef SO3_DEBUG
72 MMechostr(MSKDEBUG, "SO3FlashControlCreate\n");
73#endif
74
75#ifdef SO3_FLASH_ENABLE
76 //$BB reorder params
77 int z = MTOI(MMpull(m));
78 int h = MTOI(MMpull(m));
79 int w = MTOI(MMpull(m));
80 int topPos = MTOI(MMpull(m));
81 int leftPos = MTOI(MMpull(m));
82 int nam = MMpull(m);
83 int vp = MMpull(m);
84 int s = MMget(m, 0);
85
86 if((s==NIL)||(vp==NIL)||(nam == NIL)||(w == NIL)||(h == NIL)||(z == NIL))
87 {
88 MMset(m,0,NIL);
89 return 0;
90 }
91
92 SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
93 if(scene==NULL)
94 {
95 MMset(m, 0, NIL);
96 return 0;
97 }
98
99 SViewPort* viewport = MMgetPointer<SViewPort*>(m, MTOP(vp));
100 if(viewport==NULL)
101 {
102 MMechostr(MSKDEBUG,"vp is NULL \n");
103 MMset(m,0,NIL);
104 return 0;
105 }
106
107 std::string name(MMstartstr(m,MTOP(nam)));
108 if(name.empty())
109 {
110 MMechostr(MSKDEBUG,"name is NULL \n");
111 MMset(m,0,NIL);
112 return 0;
113 }
114
115 // Hack : If we set bigger value memset crashes : Dont' know why
116 if( w>=5000 || h>=5000)
117 {
118 MMechostr(MSKDEBUG,"too bigger values \n");
119 MMset(m, 0, NIL);
120 return 0;
121 }
122
123 SFlashWidget* mFlashControl = 0;
124 try
125 {
126 mFlashControl = static_cast<SFlashWidget*> (SWidgetManager::getSingleton().CreateWidget(scene, name, leftPos, topPos, w, h, viewport, z, SO3_FLASH_WIDGET_TYPE));
127 }
128 catch(Ogre::Exception &e)
129 {
130 MMechostr(MSKDEBUG, "An exception has occurred while creating flash widget: %s\n", e.what());
131 MMset(m, 0, NIL);
132 return 0;
133 }
134
135 //get scene scol object
136 int p = OBJfindTH(m, SO3SCENETYPE, SCOL_PTR scene);
137 // push channel
138 MMset(m, 0, MMfetch(m, p, OFFOBJCHN));
139
140 if ((MMpushPointer(m, mFlashControl) != 0))
141 {
142 SWidgetManager::getSingleton().DeleteWidget(mFlashControl);
143 MMset(m, 0, NIL);
144 return MERRMEM;
145 }
146
147 return OBJcreate(m, SO3WIDGET, SCOL_PTR mFlashControl, SO3VPTYPE, SCOL_PTR viewport);
148
149#else
150 MMechostr(MSKRUNTIME, "SO3FlashControlCreate NOT implemented\n");
151 SEDROP(m, 8);
152 MMpush(m, NIL);
153 return 0;
154#endif
155}
156
175int SO3FlashControlCreateBackground(mmachine m)
176{
177#ifdef SO3_DEBUG
178 MMechostr(MSKDEBUG, "SO3FlashControlCreateBackground\n");
179#endif
180
181#ifdef SO3_FLASH_ENABLE
182 int h = MTOI(MMpull(m));
183 int w = MTOI(MMpull(m));
184 int topPos = MTOI(MMpull(m));
185 int leftPos = MTOI(MMpull(m));
186 int nam = MMpull(m);
187 int vp = MMpull(m);
188 int s = MMget(m, 0);
189
190 if((s==NIL)||(vp==NIL)||(nam == NIL)||(w == NIL)||(h == NIL))
191 {
192 MMset(m,0,NIL);
193 return 0;
194 }
195
196 SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
197 if(scene==NULL)
198 {
199 MMset(m, 0, NIL);
200 return 0;
201 }
202
203 SViewPort* viewport = MMgetPointer<SViewPort*>(m, MTOP(vp));
204 if(viewport==NULL)
205 {
206 MMechostr(MSKDEBUG,"vp is NULL \n");
207 MMset(m,0,NIL);
208 return 0;
209 }
210
211 std::string name(MMstartstr(m,MTOP(nam)));
212 if(name.empty())
213 {
214 MMechostr(MSKDEBUG,"name is NULL \n");
215 MMset(m,0,NIL);
216 return 0;
217 }
218
219 // Hack : If we set bigger value memset crashes : Dont' know why
220 if( w>=5000 || h>=5000)
221 {
222 MMechostr(MSKDEBUG,"too bigger values \n");
223 MMset(m, 0, NIL);
224 return 0;
225 }
226
227 SFlashWidget* mFlashControl = 0;
228 try
229 {
230 mFlashControl = static_cast<SFlashWidget*> (SWidgetManager::getSingleton().CreateWidget(scene, name, leftPos, topPos, w, h, viewport, SO3_FLASH_WIDGET_TYPE));
231 }
232 catch(Ogre::Exception &e)
233 {
234 MMechostr(MSKDEBUG, "An exception has occurred while creating flash widget: %s\n", e.what());
235 MMset(m, 0, NIL);
236 return 0;
237 }
238
239 //get scene scol object
240 int p = OBJfindTH(m, SO3SCENETYPE, SCOL_PTR scene);
241 // push channel
242 MMset(m, 0, MMfetch(m, p, OFFOBJCHN));
243
244 if ((MMpushPointer(m, mFlashControl) != 0))
245 {
246 SWidgetManager::getSingleton().DeleteWidget(mFlashControl);
247 MMset(m, 0, NIL);
248 return MERRMEM;
249 }
250
251 return OBJcreate(m, SO3WIDGET, SCOL_PTR mFlashControl, SO3VPTYPE, SCOL_PTR viewport);
252
253#else
254 MMechostr(MSKRUNTIME, "SO3FlashControlCreateBackground NOT implemented\n");
255 SEDROP(m, 8);
256 MMpush(m, NIL);
257 return 0;
258#endif
259}
260
277int SO3FlashControlCreateOnMaterial(mmachine m)
278{
279#ifdef SO3_DEBUG
280 MMechostr(MSKDEBUG, "SO3FlashControlCreateOnMaterial\n");
281#endif
282
283#ifdef SO3_FLASH_ENABLE
284 int index = MTOI(MMpull(m));
285 int pass = MTOI(MMpull(m));
286 int tec = MTOI(MMpull(m));
287 int h = MMpull(m);
288 int w = MMpull(m);
289 int n = MMpull(m);
290 int mat = MMpull(m);
291 int s = MMget(m, 0);
292 if((s==NIL)||(mat==NIL)||(tec==NIL)||(pass==NIL)||(index==NIL)||(w==NIL)||(h==NIL)||(n==NIL))
293 {
294 MMset(m, 0, NIL);
295 return 0;
296 }
297
298 SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
299 if(scene==NULL)
300 {
301 MMset(m, 0, NIL);
302 return 0;
303 }
304
305 SMaterial* material = MMgetPointer<SMaterial*>(m, MTOP(mat));
306 if(material==NULL)
307 {
308 MMechostr(MSKDEBUG, "material==NULL\n");
309 MMset(m, 0, NIL);
310 return 0;
311 }
312
313 if (material->GetAssociatedWidget() != 0)
314 {
315 MMechostr(MSKDEBUG, "SO3FlashControlCreateOnMaterial : %s already have a widget on it!\n", material->GetName().c_str());
316 MMset(m, 0, NIL);
317 return 0;
318 }
319
320 std::string name(MMstartstr(m, MTOP(n)));
321 if(name.empty())
322 {
323 MMechostr(MSKDEBUG, "name is NULL \n");
324 MMset(m, 0, NIL);
325 return 0;
326 }
327
328 if(!strcmp("BaseWhite", material->getOgreMaterialPointer()->getName().c_str()))
329 {
330 Ogre::LogManager::getSingleton().logMessage("Can't load Flash Control : Material BaseWhite is Protected!", Ogre::LML_CRITICAL, true) ;
331 MMechostr(MSKDEBUG, "Material BaseWhite is Protected \n");
332 MMset(m, 0, NIL);
333 return 0;
334 }
335
336 if(material->GetNumTechniques()<tec+1)
337 {
338 Ogre::LogManager::getSingleton().logMessage("Can't load Flash Control : Material has not enough Technique! ", Ogre::LML_CRITICAL, true) ;
339 MMset(m, 0, NIL);
340 return 0;
341 }
342
343 if((material->getOgreMaterialPointer()->getTechnique(tec)->getNumPasses())<pass+1)
344 {
345 Ogre::LogManager::getSingleton().logMessage("Can't load Flash Control : Material has not enough Pass! ", Ogre::LML_CRITICAL, true) ;
346 MMset(m,0,NIL);
347 return 0;
348 }
349
350 if((material->getOgreMaterialPointer()->getTechnique(tec)->getPass(pass)->getNumTextureUnitStates())==0)
351 {
352 Ogre::LogManager::getSingleton().logMessage("Can't load Flash Control : Material has not enough Texture! ", Ogre::LML_CRITICAL, true) ;
353 MMset(m, 0, NIL);
354 return 0;
355 }
356
357 if((material->getOgreMaterialPointer()->getTechnique(tec)->getPass(pass)->getNumTextureUnitStates())<index+1)
358 {
359 Ogre::LogManager::getSingleton().logMessage("Can't load Flash Control : Material has not enough Texture! ", Ogre::LML_CRITICAL, true) ;
360 MMset(m, 0, NIL);
361 return 0;
362 }
363
364 SFlashWidget* mFlashControl = 0;
365 try
366 {
367 mFlashControl = static_cast<SFlashWidget*> (SWidgetManager::getSingleton().CreateWidget(scene, name, MTOI(w), MTOI(h), material, tec, pass, index, SO3_FLASH_WIDGET_TYPE/*pos, z*/));
368 }
369 catch(Ogre::Exception &e)
370 {
371 MMechostr(MSKDEBUG, "An exception has occurred while creating flash control: %s\n", e.what());
372 MMset(m, 0, NIL);
373 return 0;
374 }
375
376 //get scene scol object
377 int p = OBJfindTH(m, SO3SCENETYPE, SCOL_PTR scene);
378 // push channel
379 MMset(m, 0, MMfetch(m, p, OFFOBJCHN));
380
381 if ((MMpushPointer(m, mFlashControl) != 0))
382 {
383 SWidgetManager::getSingleton().DeleteWidget(mFlashControl);
384 MMset(m, 0, NIL);
385 return MERRMEM;
386 }
387
388 return OBJcreate(m, SO3WIDGET, SCOL_PTR mFlashControl, SO3MATERIAL, SCOL_PTR material);
389
390#else
391 MMechostr(MSKRUNTIME, "SO3FlashControlCreateOnMaterial NOT implemented\n");
392 SEDROP(m, 8);
393 MMpush(m, NIL);
394 return 0;
395#endif
396}
397
398
416int SO3FlashControlSetQuality(mmachine m)
417{
418#ifdef SO3_DEBUG
419 MMechostr(MSKDEBUG, "SO3FlashControlSetQuality\n");
420#endif
421
422#ifdef SO3_FLASH_ENABLE
423 int q = MMpull(m);
424 int fc = MMget(m, 0);
425 if((fc==NIL)||(q==NIL))
426 {
427 MMset(m, 0, NIL);
428 return 0;
429 }
430
431 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
432 if(widget==NULL)
433 {
434 MMechostr(MSKDEBUG, "widget instance is NULL \n");
435 MMset(m, 0, NIL);
436 return 0;
437 }
438
439 // Let's be sure that our widget is a flash control
440 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
441 {
442 MMechostr(MSKDEBUG, "bad widget type \n");
443 MMset(m, 0, NIL);
444 return 0;
445 }
446 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
447
448 // Set rendering quality
449 flashControl->SetRenderingQuality(static_cast <FlashRenderQuality> (q));
450 MMset(m, 0, ITOM(1));
451 return 0;
452
453#else
454 MMechostr(MSKRUNTIME, "SO3FlashControlSetQuality NOT implemented\n");
455 SEDROP(m, 2);
456 MMpush(m, NIL);
457 return 0;
458#endif
459}
460
461
478int SO3FlashControlGetQuality(mmachine m)
479{
480#ifdef SO3_DEBUG
481 MMechostr(MSKDEBUG, "SO3FlashControlGetQuality\n");
482#endif
483
484#ifdef SO3_FLASH_ENABLE
485 int fc = MMget(m, 0);
486 if(fc==NIL)
487 {
488 MMset(m, 0, NIL);
489 return 0;
490 }
491
492 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
493 if(widget==NULL)
494 {
495 MMechostr(MSKDEBUG, "widget instance is NULL \n");
496 MMset(m, 0, NIL);
497 return 0;
498 }
499
500 // Let's be sure that our widget is a flash control
501 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
502 {
503 MMechostr(MSKDEBUG, "bad widget type \n");
504 MMset(m, 0, NIL);
505 return 0;
506 }
507 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
508
509 // Get rendering quality
510 MMset(m, 0, ITOM(flashControl->GetRenderingQuality()));
511 return 0;
512
513#else
514 MMechostr(MSKRUNTIME, "SO3FlashControlGetQuality NOT implemented\n");
515 MMset(m, 0, NIL);
516 return 0;
517#endif
518}
519
520
534int SO3FlashControlGetScaleMode(mmachine m)
535{
536#ifdef SO3_DEBUG
537 MMechostr(MSKDEBUG, "SO3FlashControlGetScaleMode\n");
538#endif
539
540#ifdef SO3_FLASH_ENABLE
541 int fc = MMget(m, 0);
542 if(fc==NIL)
543 {
544 MMset(m, 0, NIL);
545 return 0;
546 }
547
548 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
549 if(widget==NULL)
550 {
551 MMechostr(MSKDEBUG, "widget instance is NULL \n");
552 MMset(m, 0, NIL);
553 return 0;
554 }
555
556 // Let's be sure that our widget is a flash control
557 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
558 {
559 MMechostr(MSKDEBUG, "bad widget type \n");
560 MMset(m, 0, NIL);
561 return 0;
562 }
563 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
564 MMset(m, 0, ITOM(flashControl->GetScaleMode()));
565 return 0;
566
567#else
568 MMechostr(MSKRUNTIME, "SO3FlashControlGetQuality NOT implemented\n");
569 MMset(m, 0, NIL);
570 return 0;
571#endif
572}
573
574
589int SO3FlashControlSetScaleMode(mmachine m)
590{
591#ifdef SO3_DEBUG
592 MMechostr(MSKDEBUG,"SO3FlashControlSetScaleMode\n");
593#endif
594
595#ifdef SO3_FLASH_ENABLE
596 int sm = MMpull(m);
597 int fc = MMget(m, 0);
598 if((fc==NIL)||(sm==NIL))
599 {
600 MMset(m, 0, NIL);
601 return 0;
602 }
603
604 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
605 if(widget==NULL)
606 {
607 MMechostr(MSKDEBUG, "widget instance is NULL \n");
608 MMset(m, 0, NIL);
609 return 0;
610 }
611
612 // Let's be sure that our widget is a flash control
613 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
614 {
615 MMechostr(MSKDEBUG, "bad widget type \n");
616 MMset(m, 0, NIL);
617 return 0;
618 }
619
620 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
621 flashControl->SetScaleMode(static_cast <FlashScaleMode> (MTOI(sm)));
622
623 MMset(m, 0, ITOM(1));
624 return 0;
625
626#else
627 MMechostr(MSKRUNTIME, "SO3FlashControlSetScaleMode NOT implemented\n");
628 SEDROP(m, 2);
629 MMpush(m, NIL);
630 return 0;
631#endif
632}
633
634
643int SO3FlashControlPlay(mmachine m)
644{
645#ifdef SO3_DEBUG
646 MMechostr(MSKDEBUG, "SO3FlashControlPlay\n");
647#endif
648
649#ifdef SO3_FLASH_ENABLE
650 int fc = MTOP(MMget(m, 0));
651 if(fc==NIL)
652 {
653 MMset(m, 0, NIL);
654 return 0;
655 }
656
657 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
658 if(widget==NULL)
659 {
660 MMechostr(MSKDEBUG, "widget instance is NULL \n");
661 MMset(m, 0, NIL);
662 return 0;
663 }
664
665 // Let's be sure that our widget is a flash control
666 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
667 {
668 MMechostr(MSKDEBUG, "bad widget type \n");
669 MMset(m, 0, NIL);
670 return 0;
671 }
672 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
673
674 // Playing
675 flashControl->Play();
676 MMset(m, 0, ITOM(1));
677 return 0;
678
679#else
680 MMechostr(MSKRUNTIME, "SO3FlashControlPlay NOT implemented\n");
681 MMset(m, 0, NIL);
682 return 0;
683#endif
684}
685
686
695int SO3FlashControlRewind(mmachine m)
696{
697#ifdef SO3_DEBUG
698 MMechostr(MSKDEBUG, "SO3FlashControlRewind\n");
699#endif
700
701#ifdef SO3_FLASH_ENABLE
702 int fc = MMget(m, 0);
703 if(fc==NIL)
704 {
705 MMset(m, 0, NIL);
706 return 0;
707 }
708
709 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
710 if(widget==NULL)
711 {
712 MMechostr(MSKDEBUG, "widget instance is NULL \n");
713 MMset(m, 0, NIL);
714 return 0;
715 }
716
717 // Let's be sure that our widget is a flash control
718 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
719 {
720 MMechostr(MSKDEBUG, "bad widget type \n");
721 MMset(m, 0, NIL);
722 return 0;
723 }
724 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
725
726 // Rewind flash
727 flashControl->Rewind();
728 MMset(m, 0, ITOM(1));
729 return 0;
730
731#else
732 MMechostr(MSKRUNTIME, "SO3FlashControlRewind NOT implemented\n");
733 MMset(m, 0, NIL);
734 return 0;
735#endif
736}
737
738
748int SO3FlashControlGoToFrame(mmachine m)
749{
750#ifdef SO3_DEBUG
751 MMechostr(MSKDEBUG, "SO3FlashControlGoToFrame\n");
752#endif
753
754#ifdef SO3_FLASH_ENABLE
755 int frame = MTOI(MMpull(m));
756 int fc = MTOP(MMget(m, 0));
757 if((fc==NIL)||(frame==NIL))
758 {
759 MMset(m, 0, NIL);
760 return 0;
761 }
762
763 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
764 if(widget==NULL)
765 {
766 MMechostr(MSKDEBUG, "widget instance is NULL \n");
767 MMset(m, 0, NIL);
768 return 0;
769 }
770
771 // Let's be sure that our widget is a flash control
772 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
773 {
774 MMechostr(MSKDEBUG, "bad widget type \n");
775 MMset(m, 0, NIL);
776 return 0;
777 }
778 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
779
780 // Seek to the good frame
781 flashControl->Seek((long)frame);
782 MMset(m, 0, ITOM(1));
783 return 0;
784
785#else
786 MMechostr(MSKRUNTIME, "SO3FlashControlGoToFrame NOT implemented\n");
787 SEDROP(m, 2);
788 MMpush(m, NIL);
789 return 0;
790#endif
791}
792
793
802int SO3FlashControlStop(mmachine m)
803{
804#ifdef SO3_DEBUG
805 MMechostr(MSKDEBUG, "SO3FlashControlStop\n");
806#endif
807
808#ifdef SO3_FLASH_ENABLE
809 int fc = MTOP(MMget(m, 0));
810 if(fc==NIL)
811 {
812 MMset(m, 0, NIL);
813 return 0;
814 }
815
816 SWidget* widget = MMgetPointer<SWidget*>(m, MTOP(fc));
817 if(widget==NULL)
818 {
819 MMechostr(MSKDEBUG, "widget instance is NULL \n");
820 MMset(m, 0, NIL);
821 return 0;
822 }
823
824 // Let's be sure that our widget is a flash control
825 if(widget->GetType() != SO3_FLASH_WIDGET_TYPE)
826 {
827 MMechostr(MSKDEBUG, "bad widget type \n");
828 MMset(m, 0, NIL);
829 return 0;
830 }
831 SFlashWidget* flashControl = static_cast <SFlashWidget*> (widget);
832
833 // Stopping
834 flashControl->Stop();
835 MMset(m, 0, ITOM(1));
836 return 0;
837
838#else
839 MMechostr(MSKRUNTIME, "SO3FlashControlStop NOT implemented\n");
840 MMset(m, 0, NIL);
841 return 0;
842#endif
843}
844
845
846NativeDefinition natSO3FLH[] = {
847 { "SO3FlashControlCreate", 8, "fun [SO3_SCENE SO3_VIEWPORT S I I I I I] SO3_WIDGET", SO3FlashControlCreate },
848 { "SO3FlashControlCreateBackground", 7, "fun [SO3_SCENE SO3_VIEWPORT S I I I I] SO3_WIDGET", SO3FlashControlCreateBackground },
849 { "SO3FlashControlCreateOnMaterial", 8, "fun [SO3_SCENE SO3_MATERIAL S I I I I I] SO3_WIDGET", SO3FlashControlCreateOnMaterial },
850 { "SO3FlashControlSetQuality", 2, "fun [SO3_WIDGET I] I", SO3FlashControlSetQuality },
851 { "SO3FlashControlGetScaleMode", 1, "fun [SO3_WIDGET] I", SO3FlashControlGetScaleMode },
852 { "SO3FlashControlGetQuality", 1, "fun [SO3_WIDGET] I", SO3FlashControlGetQuality },
853 { "SO3FlashControlSetScaleMode", 2, "fun [SO3_WIDGET I] I", SO3FlashControlSetScaleMode },
854 { "SO3FlashControlGoToFrame", 2, "fun [SO3_WIDGET I] I", SO3FlashControlGoToFrame },
855 { "SO3FlashControlPlay", 1, "fun [SO3_WIDGET] I", SO3FlashControlPlay },
856 { "SO3FlashControlRewind", 1, "fun [SO3_WIDGET] I", SO3FlashControlRewind },
857 { "SO3FlashControlStop", 1, "fun [SO3_WIDGET] I", SO3FlashControlStop }
858};
859
860
866int SCOLloadFlashControl(mmachine m,cbmachine w)
867{
868 return PKhardpak2(m, "SO3FLH.pkg", sizeof(natSO3FLH) / sizeof(natSO3FLH[0]), natSO3FLH);
869}
870
871
876int SCOLfreeFlashControl()
877{
878 return 0;
879}
natSO3FLH
NativeDefinition natSO3FLH[]
Definition SCOLFlashControl.cpp:846
SCOLloadFlashControl
int SCOLloadFlashControl(mmachine m, cbmachine w)
Load the SO3Engine Viewport function.
Definition SCOLFlashControl.cpp:866
SCOLfreeFlashControl
int SCOLfreeFlashControl()
free the SO3Engine Viewport function
Definition SCOLFlashControl.cpp:876
MMechostr
MMechostr(MSKDEBUG, " > Start loading Plugin SO3Engine dll\n")
w
SCOL_EXPORT int cbmachine w
Definition SO3SCOL.cpp:5150
SO3MATERIAL
int SO3MATERIAL
Definition SO3SCOL.cpp:97
SO3SCENETYPE
int SO3SCENETYPE
Definition SO3SCOL.cpp:88
SO3VPTYPE
int SO3VPTYPE
Definition SO3SCOL.cpp:94
SO3WIDGET
int SO3WIDGET
Definition SO3SCOL.cpp:101
SO3FlashControlGetQuality
int SO3FlashControlGetQuality(mmachine m)
SO3FlashControlGetQuality : Get the rendering quality of a flash control.
Definition SCOLFlashControl.cpp:478
SO3FlashControlRewind
int SO3FlashControlRewind(mmachine m)
SO3FlashControlRewind : To Rewind a flash control.
Definition SCOLFlashControl.cpp:695
SO3FlashControlStop
int SO3FlashControlStop(mmachine m)
SO3FlashControlStop : To Stop a flash control.
Definition SCOLFlashControl.cpp:802
SO3FlashControlGoToFrame
int SO3FlashControlGoToFrame(mmachine m)
SO3FlashControlGoToFrame : Go to a given flash frame.
Definition SCOLFlashControl.cpp:748
SO3FlashControlSetQuality
int SO3FlashControlSetQuality(mmachine m)
SO3FlashControlSetQuality : defines the rendering quality for a flash control.
Definition SCOLFlashControl.cpp:416
SO3FlashControlCreateBackground
int SO3FlashControlCreateBackground(mmachine m)
SO3FlashControlCreateBackground : Create a new flash control.
Definition SCOLFlashControl.cpp:175
SO3FlashControlCreate
int SO3FlashControlCreate(mmachine m)
main include
Definition SCOLFlashControl.cpp:69
SO3FlashControlSetScaleMode
int SO3FlashControlSetScaleMode(mmachine m)
SO3FlashControlSetScaleMode : defines scale mode for a flash control.
Definition SCOLFlashControl.cpp:589
SO3FlashControlPlay
int SO3FlashControlPlay(mmachine m)
SO3FlashControlPlay : To play a flash control.
Definition SCOLFlashControl.cpp:643
SO3FlashControlGetScaleMode
int SO3FlashControlGetScaleMode(mmachine m)
SO3FlashControlGetScaleMode : Get the scale mode of a flash control.
Definition SCOLFlashControl.cpp:534
SO3FlashControlCreateOnMaterial
int SO3FlashControlCreateOnMaterial(mmachine m)
SO3FlashControlCreateOnMaterial : Set a texture flash on a material.
Definition SCOLFlashControl.cpp:277
Generated by doxygen 1.9.8