1 /* NAME:
2 QD3DGeometry.c
3
4 DESCRIPTION:
5 Entry point for Quesa API calls. Performs parameter checking and
6 then forwards each API call to the equivalent E3xxxxx routine.
7
8 COPYRIGHT:
9 Copyright (c) 1999-2005, Quesa Developers. All rights reserved.
10
11 For the current release of Quesa, please see:
12
13 <http://www.quesa.org/>
14
15 Redistribution and use in source and binary forms, with or without
16 modification, are permitted provided that the following conditions
17 are met:
18
19 o Redistributions of source code must retain the above copyright
20 notice, this list of conditions and the following disclaimer.
21
22 o Redistributions in binary form must reproduce the above
23 copyright notice, this list of conditions and the following
24 disclaimer in the documentation and/or other materials provided
25 with the distribution.
26
27 o Neither the name of Quesa nor the names of its contributors
28 may be used to endorse or promote products derived from this
29 software without specific prior written permission.
30
31 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
36 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
37 TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
38 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
39 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
40 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
41 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42 ___________________________________________________________________________
43 */
44 //=============================================================================
45 // Include files
46 //-----------------------------------------------------------------------------
47 #include "E3Prefix.h"
48 #include "E3Geometry.h"
49 #include "E3GeometryBox.h"
50 #include "E3GeometryCone.h"
51 #include "E3GeometryCylinder.h"
52 #include "E3GeometryDisk.h"
53 #include "E3GeometryEllipse.h"
54 #include "E3GeometryEllipsoid.h"
55 #include "E3GeometryGeneralPolygon.h"
56 #include "E3GeometryLine.h"
57 #include "E3GeometryMarker.h"
58 #include "E3GeometryMesh.h"
59 #include "E3GeometryNURBCurve.h"
60 #include "E3GeometryNURBPatch.h"
61 #include "E3GeometryPixmapMarker.h"
62 #include "E3GeometryPoint.h"
63 #include "E3GeometryPolyhedron.h"
64 #include "E3GeometryPolyLine.h"
65 #include "E3GeometryPolygon.h"
66 #include "E3GeometryTorus.h"
67 #include "E3GeometryTriangle.h"
68 #include "E3GeometryTriGrid.h"
69 #include "E3GeometryTriMesh.h"
70 #include "E3GeometryTriMeshOptimize.h"
71 #include "E3View.h"
72
73
74
75
76
77 //=============================================================================
78 // Internal constants
79 //-----------------------------------------------------------------------------
80 // Internal constants go here
81
82
83
84
85
86 //=============================================================================
87 // Internal types
88 //-----------------------------------------------------------------------------
89 // Internal types go here
90
91
92
93
94
95 //=============================================================================
96 // Internal macros
97 //-----------------------------------------------------------------------------
98 // Internal macros go here
99
100
101
102
103
104 //=============================================================================
105 // Public functions
106 //-----------------------------------------------------------------------------
107 // Q3Geometry_GetType : Quesa API entry point.
108 //-----------------------------------------------------------------------------
109 TQ3ObjectType
Q3Geometry_GetType(TQ3GeometryObject geometry)110 Q3Geometry_GetType(TQ3GeometryObject geometry)
111 {
112
113
114 // Release build checks
115 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3ObjectTypeInvalid);
116
117
118
119 // Debug build checks
120 #if Q3_DEBUG
121 if (0) // Further checks on geometry
122 return(kQ3ObjectTypeInvalid);
123 #endif
124
125
126
127 // Call the bottleneck
128 E3System_Bottleneck();
129
130
131
132 // Call our implementation
133 return(E3Geometry_GetType(geometry));
134 }
135
136
137
138
139
140 //=============================================================================
141 // Q3Geometry_GetAttributeSet : Quesa API entry point.
142 //-----------------------------------------------------------------------------
143 TQ3Status
Q3Geometry_GetAttributeSet(TQ3GeometryObject geometry,TQ3AttributeSet * attributeSet)144 Q3Geometry_GetAttributeSet(TQ3GeometryObject geometry, TQ3AttributeSet *attributeSet)
145 {
146
147
148 // Release build checks
149 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
150 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
151
152
153
154 // Debug build checks
155 #if Q3_DEBUG
156 if (0) // Further checks on geometry
157 return(kQ3Failure);
158
159 if (0) // Further checks on attributeSet
160 return(kQ3Failure);
161 #endif
162
163
164
165 // Call the bottleneck
166 E3System_Bottleneck();
167
168
169
170 // Call our implementation
171 return(E3Geometry_GetAttributeSet(geometry, attributeSet));
172 }
173
174
175
176
177
178 //=============================================================================
179 // Q3Geometry_SetAttributeSet : Quesa API entry point.
180 //-----------------------------------------------------------------------------
181 TQ3Status
Q3Geometry_SetAttributeSet(TQ3GeometryObject geometry,TQ3AttributeSet attributeSet)182 Q3Geometry_SetAttributeSet(TQ3GeometryObject geometry, TQ3AttributeSet attributeSet)
183 {
184
185
186 // Release build checks
187 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
188
189
190
191 // Debug build checks
192 #if Q3_DEBUG
193 if (0) // Further checks on geometry
194 return(kQ3Failure);
195
196 if (0) // Further checks on attributeSet
197 return(kQ3Failure);
198 #endif
199
200
201
202 // Call the bottleneck
203 E3System_Bottleneck();
204
205
206
207 // Call our implementation
208 return(E3Geometry_SetAttributeSet(geometry, attributeSet));
209 }
210
211
212
213
214
215 //=============================================================================
216 // Q3Geometry_Submit : Quesa API entry point.
217 //-----------------------------------------------------------------------------
218 TQ3Status
Q3Geometry_Submit(TQ3GeometryObject geometry,TQ3ViewObject view)219 Q3Geometry_Submit(TQ3GeometryObject geometry, TQ3ViewObject view)
220 {
221 // Release build checks
222 Q3_REQUIRE_OR_RESULT( geometry->IsObjectValid () , kQ3Failure ) ;
223 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
224
225 #if !QUESA_BUILD_AS_BINARY_COMPATIBLE
226 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
227 #endif
228
229
230
231 // Debug build checks
232 #if Q3_DEBUG
233 if (0) // Further checks on geometry
234 return(kQ3Failure);
235
236 if (0) // Further checks on view
237 return(kQ3Failure);
238 #endif
239
240
241
242 // Call the bottleneck
243 E3System_Bottleneck();
244
245
246
247 // Call our implementation
248 TQ3Status qd3dStatus = E3Geometry_Submit(geometry, view);
249
250
251
252 // If we're binary compatible, post an error if we're mis-used
253 #if QUESA_BUILD_AS_BINARY_COMPATIBLE
254 if (! E3Geometry_IsOfMyClass ( geometry ))
255 E3ErrorManager_PostError(kQ3ErrorInvalidObjectType, kQ3False);
256 #endif
257
258 return qd3dStatus ;
259 }
260
261
262
263
264
265 //=============================================================================
266 // Q3Geometry_GetDecomposed : Quesa API entry point.
267 //-----------------------------------------------------------------------------
268 TQ3Object
Q3Geometry_GetDecomposed(TQ3GeometryObject geometry,TQ3ViewObject view)269 Q3Geometry_GetDecomposed(TQ3GeometryObject geometry, TQ3ViewObject view)
270 {
271
272
273 // Release build checks
274 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), NULL);
275 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), NULL);
276
277
278
279 // Debug build checks
280 #if Q3_DEBUG
281 if (0) // Further checks on geometry
282 return(NULL);
283
284 if (0) // Further checks on view
285 return(NULL);
286 #endif
287
288
289
290 // Call the bottleneck
291 E3System_Bottleneck();
292
293
294
295 // Call our implementation
296 return(E3Geometry_GetDecomposed(geometry, view));
297 }
298
299
300
301
302
303 //=============================================================================
304 // Q3Box_New : Quesa API entry point.
305 //-----------------------------------------------------------------------------
306 TQ3GeometryObject
Q3Box_New(const TQ3BoxData * boxData)307 Q3Box_New(const TQ3BoxData *boxData)
308 {
309
310
311 // Release build checks
312 Q3_REQUIRE_OR_RESULT( Q3_VALID_PTR(boxData) || (boxData == NULL), NULL);
313
314
315
316 // Debug build checks
317 #if Q3_DEBUG
318 if (0) // Further checks on boxData
319 return(NULL);
320 #endif
321
322
323
324 // Call the bottleneck
325 E3System_Bottleneck();
326
327
328
329 // Call our implementation
330 return(E3Box_New(boxData));
331 }
332
333
334
335
336
337 //=============================================================================
338 // Q3Box_Submit : Quesa API entry point.
339 //-----------------------------------------------------------------------------
340 TQ3Status
Q3Box_Submit(const TQ3BoxData * boxData,TQ3ViewObject view)341 Q3Box_Submit(const TQ3BoxData *boxData, TQ3ViewObject view)
342 {
343
344
345 // Release build checks
346 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(boxData), kQ3Failure);
347 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
348
349
350
351 // Debug build checks
352 #if Q3_DEBUG
353 if (0) // Further checks on boxData
354 return(kQ3Failure);
355
356 if (0) // Further checks on view
357 return(kQ3Failure);
358 #endif
359
360
361
362 // Call the bottleneck
363 E3System_Bottleneck();
364
365
366
367 // Call our implementation
368 return(E3Box_Submit(boxData, view));
369 }
370
371
372
373
374
375 //=============================================================================
376 // Q3Box_SetData : Quesa API entry point.
377 //-----------------------------------------------------------------------------
378 TQ3Status
Q3Box_SetData(TQ3GeometryObject box,const TQ3BoxData * boxData)379 Q3Box_SetData(TQ3GeometryObject box, const TQ3BoxData *boxData)
380 {
381
382
383 // Release build checks
384 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
385 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(boxData), kQ3Failure);
386
387
388
389 // Debug build checks
390 #if Q3_DEBUG
391 if (0) // Further checks on box
392 return(kQ3Failure);
393
394 if (0) // Further checks on boxData
395 return(kQ3Failure);
396 #endif
397
398
399
400 // Call the bottleneck
401 E3System_Bottleneck();
402
403
404
405 // Call our implementation
406 return(E3Box_SetData(box, boxData));
407 }
408
409
410
411
412
413 //=============================================================================
414 // Q3Box_GetData : Quesa API entry point.
415 //-----------------------------------------------------------------------------
416 TQ3Status
Q3Box_GetData(TQ3GeometryObject box,TQ3BoxData * boxData)417 Q3Box_GetData(TQ3GeometryObject box, TQ3BoxData *boxData)
418 {
419
420
421 // Release build checks
422 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
423 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(boxData), kQ3Failure);
424
425
426
427 // Debug build checks
428 #if Q3_DEBUG
429 if (0) // Further checks on box
430 return(kQ3Failure);
431
432 if (0) // Further checks on boxData
433 return(kQ3Failure);
434 #endif
435
436
437
438 // Call the bottleneck
439 E3System_Bottleneck();
440
441
442
443 // Call our implementation
444 return(E3Box_GetData(box, boxData));
445 }
446
447
448
449
450
451 //=============================================================================
452 // Q3Box_EmptyData : Quesa API entry point.
453 //-----------------------------------------------------------------------------
454 TQ3Status
Q3Box_EmptyData(TQ3BoxData * boxData)455 Q3Box_EmptyData(TQ3BoxData *boxData)
456 {
457
458
459 // Release build checks
460 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(boxData), kQ3Failure);
461
462
463
464 // Debug build checks
465 #if Q3_DEBUG
466 if (0) // Further checks on boxData
467 return(kQ3Failure);
468 #endif
469
470
471
472 // Call the bottleneck
473 E3System_Bottleneck();
474
475
476
477 // Call our implementation
478 return(E3Box_EmptyData(boxData));
479 }
480
481
482
483
484
485 //=============================================================================
486 // Q3Box_SetOrigin : Quesa API entry point.
487 //-----------------------------------------------------------------------------
488 TQ3Status
Q3Box_SetOrigin(TQ3GeometryObject box,const TQ3Point3D * origin)489 Q3Box_SetOrigin(TQ3GeometryObject box, const TQ3Point3D *origin)
490 {
491
492
493 // Release build checks
494 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
495 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
496
497
498
499 // Debug build checks
500 #if Q3_DEBUG
501 if (0) // Further checks on box
502 return(kQ3Failure);
503
504 if (0) // Further checks on origin
505 return(kQ3Failure);
506 #endif
507
508
509
510 // Call the bottleneck
511 E3System_Bottleneck();
512
513
514
515 // Call our implementation
516 return(E3Box_SetOrigin(box, origin));
517 }
518
519
520
521
522
523 //=============================================================================
524 // Q3Box_SetOrientation : Quesa API entry point.
525 //-----------------------------------------------------------------------------
526 TQ3Status
Q3Box_SetOrientation(TQ3GeometryObject box,const TQ3Vector3D * orientation)527 Q3Box_SetOrientation(TQ3GeometryObject box, const TQ3Vector3D *orientation)
528 {
529
530
531 // Release build checks
532 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
533 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
534
535
536
537 // Debug build checks
538 #if Q3_DEBUG
539 if (0) // Further checks on box
540 return(kQ3Failure);
541
542 if (0) // Further checks on orientation
543 return(kQ3Failure);
544 #endif
545
546
547
548 // Call the bottleneck
549 E3System_Bottleneck();
550
551
552
553 // Call our implementation
554 return(E3Box_SetOrientation(box, orientation));
555 }
556
557
558
559
560
561 //=============================================================================
562 // Q3Box_SetMajorAxis : Quesa API entry point.
563 //-----------------------------------------------------------------------------
564 TQ3Status
Q3Box_SetMajorAxis(TQ3GeometryObject box,const TQ3Vector3D * majorAxis)565 Q3Box_SetMajorAxis(TQ3GeometryObject box, const TQ3Vector3D *majorAxis)
566 {
567
568
569 // Release build checks
570 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
571 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorAxis), kQ3Failure);
572
573
574
575 // Debug build checks
576 #if Q3_DEBUG
577 if (0) // Further checks on box
578 return(kQ3Failure);
579
580 if (0) // Further checks on majorAxis
581 return(kQ3Failure);
582 #endif
583
584
585
586 // Call the bottleneck
587 E3System_Bottleneck();
588
589
590
591 // Call our implementation
592 return(E3Box_SetMajorAxis(box, majorAxis));
593 }
594
595
596
597
598
599 //=============================================================================
600 // Q3Box_SetMinorAxis : Quesa API entry point.
601 //-----------------------------------------------------------------------------
602 TQ3Status
Q3Box_SetMinorAxis(TQ3GeometryObject box,const TQ3Vector3D * minorAxis)603 Q3Box_SetMinorAxis(TQ3GeometryObject box, const TQ3Vector3D *minorAxis)
604 {
605
606
607 // Release build checks
608 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
609 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorAxis), kQ3Failure);
610
611
612
613 // Debug build checks
614 #if Q3_DEBUG
615 if (0) // Further checks on box
616 return(kQ3Failure);
617
618 if (0) // Further checks on minorAxis
619 return(kQ3Failure);
620 #endif
621
622
623
624 // Call the bottleneck
625 E3System_Bottleneck();
626
627
628
629 // Call our implementation
630 return(E3Box_SetMinorAxis(box, minorAxis));
631 }
632
633
634
635
636
637 //=============================================================================
638 // Q3Box_GetOrigin : Quesa API entry point.
639 //-----------------------------------------------------------------------------
640 TQ3Status
Q3Box_GetOrigin(TQ3GeometryObject box,TQ3Point3D * origin)641 Q3Box_GetOrigin(TQ3GeometryObject box, TQ3Point3D *origin)
642 {
643
644
645 // Release build checks
646 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
647 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
648
649
650
651 // Debug build checks
652 #if Q3_DEBUG
653 if (0) // Further checks on box
654 return(kQ3Failure);
655
656 if (0) // Further checks on origin
657 return(kQ3Failure);
658 #endif
659
660
661
662 // Call the bottleneck
663 E3System_Bottleneck();
664
665
666
667 // Call our implementation
668 return(E3Box_GetOrigin(box, origin));
669 }
670
671
672
673
674
675 //=============================================================================
676 // Q3Box_GetOrientation : Quesa API entry point.
677 //-----------------------------------------------------------------------------
678 TQ3Status
Q3Box_GetOrientation(TQ3GeometryObject box,TQ3Vector3D * orientation)679 Q3Box_GetOrientation(TQ3GeometryObject box, TQ3Vector3D *orientation)
680 {
681
682
683 // Release build checks
684 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
685 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
686
687
688
689 // Debug build checks
690 #if Q3_DEBUG
691 if (0) // Further checks on box
692 return(kQ3Failure);
693
694 if (0) // Further checks on orientation
695 return(kQ3Failure);
696 #endif
697
698
699
700 // Call the bottleneck
701 E3System_Bottleneck();
702
703
704
705 // Call our implementation
706 return(E3Box_GetOrientation(box, orientation));
707 }
708
709
710
711
712
713 //=============================================================================
714 // Q3Box_GetMajorAxis : Quesa API entry point.
715 //-----------------------------------------------------------------------------
716 TQ3Status
Q3Box_GetMajorAxis(TQ3GeometryObject box,TQ3Vector3D * majorAxis)717 Q3Box_GetMajorAxis(TQ3GeometryObject box, TQ3Vector3D *majorAxis)
718 {
719
720
721 // Release build checks
722 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
723 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorAxis), kQ3Failure);
724
725
726
727 // Debug build checks
728 #if Q3_DEBUG
729 if (0) // Further checks on box
730 return(kQ3Failure);
731
732 if (0) // Further checks on majorAxis
733 return(kQ3Failure);
734 #endif
735
736
737
738 // Call the bottleneck
739 E3System_Bottleneck();
740
741
742
743 // Call our implementation
744 return(E3Box_GetMajorAxis(box, majorAxis));
745 }
746
747
748
749
750
751 //=============================================================================
752 // Q3Box_GetMinorAxis : Quesa API entry point.
753 //-----------------------------------------------------------------------------
754 TQ3Status
Q3Box_GetMinorAxis(TQ3GeometryObject box,TQ3Vector3D * minorAxis)755 Q3Box_GetMinorAxis(TQ3GeometryObject box, TQ3Vector3D *minorAxis)
756 {
757
758
759 // Release build checks
760 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
761 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorAxis), kQ3Failure);
762
763
764
765 // Debug build checks
766 #if Q3_DEBUG
767 if (0) // Further checks on box
768 return(kQ3Failure);
769
770 if (0) // Further checks on minorAxis
771 return(kQ3Failure);
772 #endif
773
774
775
776 // Call the bottleneck
777 E3System_Bottleneck();
778
779
780
781 // Call our implementation
782 return(E3Box_GetMinorAxis(box, minorAxis));
783 }
784
785
786
787
788
789 //=============================================================================
790 // Q3Box_GetFaceAttributeSet : Quesa API entry point.
791 //-----------------------------------------------------------------------------
792 TQ3Status
Q3Box_GetFaceAttributeSet(TQ3GeometryObject box,TQ3Uns32 faceIndex,TQ3AttributeSet * faceAttributeSet)793 Q3Box_GetFaceAttributeSet(TQ3GeometryObject box, TQ3Uns32 faceIndex, TQ3AttributeSet *faceAttributeSet)
794 {
795
796
797 // Release build checks
798 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
799 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(faceAttributeSet), kQ3Failure);
800
801
802
803 // Debug build checks
804 #if Q3_DEBUG
805 if (0) // Further checks on box
806 return(kQ3Failure);
807
808 if (0) // Further checks on faceIndex
809 return(kQ3Failure);
810
811 if (0) // Further checks on faceAttributeSet
812 return(kQ3Failure);
813 #endif
814
815
816
817 // Call the bottleneck
818 E3System_Bottleneck();
819
820
821
822 // Call our implementation
823 return(E3Box_GetFaceAttributeSet(box, faceIndex, faceAttributeSet));
824 }
825
826
827
828
829
830 //=============================================================================
831 // Q3Box_SetFaceAttributeSet : Quesa API entry point.
832 //-----------------------------------------------------------------------------
833 TQ3Status
Q3Box_SetFaceAttributeSet(TQ3GeometryObject box,TQ3Uns32 faceIndex,TQ3AttributeSet faceAttributeSet)834 Q3Box_SetFaceAttributeSet(TQ3GeometryObject box, TQ3Uns32 faceIndex, TQ3AttributeSet faceAttributeSet)
835 {
836
837
838 // Release build checks
839 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( box ), kQ3Failure);
840
841
842
843 // Debug build checks
844 #if Q3_DEBUG
845 if (0) // Further checks on box
846 return(kQ3Failure);
847
848 if (0) // Further checks on faceIndex
849 return(kQ3Failure);
850
851 if (0) // Further checks on faceAttributeSet
852 return(kQ3Failure);
853 #endif
854
855
856
857 // Call the bottleneck
858 E3System_Bottleneck();
859
860
861
862 // Call our implementation
863 return(E3Box_SetFaceAttributeSet(box, faceIndex, faceAttributeSet));
864 }
865
866
867
868
869
870 //=============================================================================
871 // Q3Cone_New : Quesa API entry point.
872 //-----------------------------------------------------------------------------
873 TQ3GeometryObject
Q3Cone_New(const TQ3ConeData * coneData)874 Q3Cone_New(const TQ3ConeData *coneData)
875 {
876
877
878 // Release build checks
879 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coneData) || (coneData == NULL), NULL);
880
881
882
883 // Debug build checks
884 #if Q3_DEBUG
885 if (0) // Further checks on coneData
886 return(NULL);
887 #endif
888
889
890
891 // Call the bottleneck
892 E3System_Bottleneck();
893
894
895
896 // Call our implementation
897 return(E3Cone_New(coneData));
898 }
899
900
901
902
903
904 //=============================================================================
905 // Q3Cone_Submit : Quesa API entry point.
906 //-----------------------------------------------------------------------------
907 TQ3Status
Q3Cone_Submit(const TQ3ConeData * coneData,TQ3ViewObject view)908 Q3Cone_Submit(const TQ3ConeData *coneData, TQ3ViewObject view)
909 {
910
911
912 // Release build checks
913 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coneData), kQ3Failure);
914 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
915
916
917
918 // Debug build checks
919 #if Q3_DEBUG
920 if (0) // Further checks on coneData
921 return(kQ3Failure);
922
923 if (0) // Further checks on view
924 return(kQ3Failure);
925 #endif
926
927
928
929 // Call the bottleneck
930 E3System_Bottleneck();
931
932
933
934 // Call our implementation
935 return(E3Cone_Submit(coneData, view));
936 }
937
938
939
940
941
942 //=============================================================================
943 // Q3Cone_SetData : Quesa API entry point.
944 //-----------------------------------------------------------------------------
945 TQ3Status
Q3Cone_SetData(TQ3GeometryObject cone,const TQ3ConeData * coneData)946 Q3Cone_SetData(TQ3GeometryObject cone, const TQ3ConeData *coneData)
947 {
948
949
950 // Release build checks
951 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
952 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coneData), kQ3Failure);
953
954
955
956 // Debug build checks
957 #if Q3_DEBUG
958 if (0) // Further checks on cone
959 return(kQ3Failure);
960
961 if (0) // Further checks on coneData
962 return(kQ3Failure);
963 #endif
964
965
966
967 // Call the bottleneck
968 E3System_Bottleneck();
969
970
971
972 // Call our implementation
973 return(E3Cone_SetData(cone, coneData));
974 }
975
976
977
978
979
980 //=============================================================================
981 // Q3Cone_GetData : Quesa API entry point.
982 //-----------------------------------------------------------------------------
983 TQ3Status
Q3Cone_GetData(TQ3GeometryObject cone,TQ3ConeData * coneData)984 Q3Cone_GetData(TQ3GeometryObject cone, TQ3ConeData *coneData)
985 {
986
987
988 // Release build checks
989 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
990 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coneData), kQ3Failure);
991
992
993
994 // Debug build checks
995 #if Q3_DEBUG
996 if (0) // Further checks on cone
997 return(kQ3Failure);
998
999 if (0) // Further checks on coneData
1000 return(kQ3Failure);
1001 #endif
1002
1003
1004
1005 // Call the bottleneck
1006 E3System_Bottleneck();
1007
1008
1009
1010 // Call our implementation
1011 return(E3Cone_GetData(cone, coneData));
1012 }
1013
1014
1015
1016
1017
1018 //=============================================================================
1019 // Q3Cone_SetOrigin : Quesa API entry point.
1020 //-----------------------------------------------------------------------------
1021 TQ3Status
Q3Cone_SetOrigin(TQ3GeometryObject cone,const TQ3Point3D * origin)1022 Q3Cone_SetOrigin(TQ3GeometryObject cone, const TQ3Point3D *origin)
1023 {
1024
1025
1026 // Release build checks
1027 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1028 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
1029
1030
1031
1032 // Debug build checks
1033 #if Q3_DEBUG
1034 if (0) // Further checks on cone
1035 return(kQ3Failure);
1036
1037 if (0) // Further checks on origin
1038 return(kQ3Failure);
1039 #endif
1040
1041
1042
1043 // Call the bottleneck
1044 E3System_Bottleneck();
1045
1046
1047
1048 // Call our implementation
1049 return(E3Cone_SetOrigin(cone, origin));
1050 }
1051
1052
1053
1054
1055
1056 //=============================================================================
1057 // Q3Cone_SetOrientation : Quesa API entry point.
1058 //-----------------------------------------------------------------------------
1059 TQ3Status
Q3Cone_SetOrientation(TQ3GeometryObject cone,const TQ3Vector3D * orientation)1060 Q3Cone_SetOrientation(TQ3GeometryObject cone, const TQ3Vector3D *orientation)
1061 {
1062
1063
1064 // Release build checks
1065 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1066 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
1067
1068
1069
1070 // Debug build checks
1071 #if Q3_DEBUG
1072 if (0) // Further checks on cone
1073 return(kQ3Failure);
1074
1075 if (0) // Further checks on orientation
1076 return(kQ3Failure);
1077 #endif
1078
1079
1080
1081 // Call the bottleneck
1082 E3System_Bottleneck();
1083
1084
1085
1086 // Call our implementation
1087 return(E3Cone_SetOrientation(cone, orientation));
1088 }
1089
1090
1091
1092
1093
1094 //=============================================================================
1095 // Q3Cone_SetMajorRadius : Quesa API entry point.
1096 //-----------------------------------------------------------------------------
1097 TQ3Status
Q3Cone_SetMajorRadius(TQ3GeometryObject cone,const TQ3Vector3D * majorRadius)1098 Q3Cone_SetMajorRadius(TQ3GeometryObject cone, const TQ3Vector3D *majorRadius)
1099 {
1100
1101
1102 // Release build checks
1103 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1104 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
1105
1106
1107
1108 // Debug build checks
1109 #if Q3_DEBUG
1110 if (0) // Further checks on cone
1111 return(kQ3Failure);
1112
1113 if (0) // Further checks on majorRadius
1114 return(kQ3Failure);
1115 #endif
1116
1117
1118
1119 // Call the bottleneck
1120 E3System_Bottleneck();
1121
1122
1123
1124 // Call our implementation
1125 return(E3Cone_SetMajorRadius(cone, majorRadius));
1126 }
1127
1128
1129
1130
1131
1132 //=============================================================================
1133 // Q3Cone_SetMinorRadius : Quesa API entry point.
1134 //-----------------------------------------------------------------------------
1135 TQ3Status
Q3Cone_SetMinorRadius(TQ3GeometryObject cone,const TQ3Vector3D * minorRadius)1136 Q3Cone_SetMinorRadius(TQ3GeometryObject cone, const TQ3Vector3D *minorRadius)
1137 {
1138
1139
1140 // Release build checks
1141 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1142 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
1143
1144
1145
1146 // Debug build checks
1147 #if Q3_DEBUG
1148 if (0) // Further checks on cone
1149 return(kQ3Failure);
1150
1151 if (0) // Further checks on minorRadius
1152 return(kQ3Failure);
1153 #endif
1154
1155
1156
1157 // Call the bottleneck
1158 E3System_Bottleneck();
1159
1160
1161
1162 // Call our implementation
1163 return(E3Cone_SetMinorRadius(cone, minorRadius));
1164 }
1165
1166
1167
1168
1169
1170 //=============================================================================
1171 // Q3Cone_GetOrigin : Quesa API entry point.
1172 //-----------------------------------------------------------------------------
1173 TQ3Status
Q3Cone_GetOrigin(TQ3GeometryObject cone,TQ3Point3D * origin)1174 Q3Cone_GetOrigin(TQ3GeometryObject cone, TQ3Point3D *origin)
1175 {
1176
1177
1178 // Release build checks
1179 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1180 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
1181
1182
1183
1184 // Debug build checks
1185 #if Q3_DEBUG
1186 if (0) // Further checks on cone
1187 return(kQ3Failure);
1188
1189 if (0) // Further checks on origin
1190 return(kQ3Failure);
1191 #endif
1192
1193
1194
1195 // Call the bottleneck
1196 E3System_Bottleneck();
1197
1198
1199
1200 // Call our implementation
1201 return(E3Cone_GetOrigin(cone, origin));
1202 }
1203
1204
1205
1206
1207
1208 //=============================================================================
1209 // Q3Cone_GetOrientation : Quesa API entry point.
1210 //-----------------------------------------------------------------------------
1211 TQ3Status
Q3Cone_GetOrientation(TQ3GeometryObject cone,TQ3Vector3D * orientation)1212 Q3Cone_GetOrientation(TQ3GeometryObject cone, TQ3Vector3D *orientation)
1213 {
1214
1215
1216 // Release build checks
1217 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1218 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
1219
1220
1221
1222 // Debug build checks
1223 #if Q3_DEBUG
1224 if (0) // Further checks on cone
1225 return(kQ3Failure);
1226
1227 if (0) // Further checks on orientation
1228 return(kQ3Failure);
1229 #endif
1230
1231
1232
1233 // Call the bottleneck
1234 E3System_Bottleneck();
1235
1236
1237
1238 // Call our implementation
1239 return(E3Cone_GetOrientation(cone, orientation));
1240 }
1241
1242
1243
1244
1245
1246 //=============================================================================
1247 // Q3Cone_GetMajorRadius : Quesa API entry point.
1248 //-----------------------------------------------------------------------------
1249 TQ3Status
Q3Cone_GetMajorRadius(TQ3GeometryObject cone,TQ3Vector3D * majorRadius)1250 Q3Cone_GetMajorRadius(TQ3GeometryObject cone, TQ3Vector3D *majorRadius)
1251 {
1252
1253
1254 // Release build checks
1255 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1256 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
1257
1258
1259
1260 // Debug build checks
1261 #if Q3_DEBUG
1262 if (0) // Further checks on cone
1263 return(kQ3Failure);
1264
1265 if (0) // Further checks on majorRadius
1266 return(kQ3Failure);
1267 #endif
1268
1269
1270
1271 // Call the bottleneck
1272 E3System_Bottleneck();
1273
1274
1275
1276 // Call our implementation
1277 return(E3Cone_GetMajorRadius(cone, majorRadius));
1278 }
1279
1280
1281
1282
1283
1284 //=============================================================================
1285 // Q3Cone_GetMinorRadius : Quesa API entry point.
1286 //-----------------------------------------------------------------------------
1287 TQ3Status
Q3Cone_GetMinorRadius(TQ3GeometryObject cone,TQ3Vector3D * minorRadius)1288 Q3Cone_GetMinorRadius(TQ3GeometryObject cone, TQ3Vector3D *minorRadius)
1289 {
1290
1291
1292 // Release build checks
1293 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1294 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
1295
1296
1297
1298 // Debug build checks
1299 #if Q3_DEBUG
1300 if (0) // Further checks on cone
1301 return(kQ3Failure);
1302
1303 if (0) // Further checks on minorRadius
1304 return(kQ3Failure);
1305 #endif
1306
1307
1308
1309 // Call the bottleneck
1310 E3System_Bottleneck();
1311
1312
1313
1314 // Call our implementation
1315 return(E3Cone_GetMinorRadius(cone, minorRadius));
1316 }
1317
1318
1319
1320
1321
1322 //=============================================================================
1323 // Q3Cone_SetCaps : Quesa API entry point.
1324 //-----------------------------------------------------------------------------
1325 TQ3Status
Q3Cone_SetCaps(TQ3GeometryObject cone,TQ3EndCap caps)1326 Q3Cone_SetCaps(TQ3GeometryObject cone, TQ3EndCap caps)
1327 {
1328
1329
1330 // Release build checks
1331 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1332
1333
1334
1335 // Debug build checks
1336 #if Q3_DEBUG
1337 if (0) // Further checks on cone
1338 return(kQ3Failure);
1339
1340 if (0) // Further checks on caps
1341 return(kQ3Failure);
1342 #endif
1343
1344
1345
1346 // Call the bottleneck
1347 E3System_Bottleneck();
1348
1349
1350
1351 // Call our implementation
1352 return(E3Cone_SetCaps(cone, caps));
1353 }
1354
1355
1356
1357
1358
1359 //=============================================================================
1360 // Q3Cone_GetCaps : Quesa API entry point.
1361 //-----------------------------------------------------------------------------
1362 TQ3Status
Q3Cone_GetCaps(TQ3GeometryObject cone,TQ3EndCap * caps)1363 Q3Cone_GetCaps(TQ3GeometryObject cone, TQ3EndCap *caps)
1364 {
1365
1366
1367 // Release build checks
1368 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1369 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(caps), kQ3Failure);
1370
1371
1372
1373 // Debug build checks
1374 #if Q3_DEBUG
1375 if (0) // Further checks on cone
1376 return(kQ3Failure);
1377
1378 if (0) // Further checks on caps
1379 return(kQ3Failure);
1380 #endif
1381
1382
1383
1384 // Call the bottleneck
1385 E3System_Bottleneck();
1386
1387
1388
1389 // Call our implementation
1390 return(E3Cone_GetCaps(cone, caps));
1391 }
1392
1393
1394
1395
1396
1397 //=============================================================================
1398 // Q3Cone_SetBottomAttributeSet : Quesa API entry point.
1399 //-----------------------------------------------------------------------------
1400 TQ3Status
Q3Cone_SetBottomAttributeSet(TQ3GeometryObject cone,TQ3AttributeSet bottomAttributeSet)1401 Q3Cone_SetBottomAttributeSet(TQ3GeometryObject cone, TQ3AttributeSet bottomAttributeSet)
1402 {
1403
1404
1405 // Release build checks
1406 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1407
1408
1409
1410 // Debug build checks
1411 #if Q3_DEBUG
1412 if (0) // Further checks on cone
1413 return(kQ3Failure);
1414
1415 if (0) // Further checks on bottomAttributeSet
1416 return(kQ3Failure);
1417 #endif
1418
1419
1420
1421 // Call the bottleneck
1422 E3System_Bottleneck();
1423
1424
1425
1426 // Call our implementation
1427 return(E3Cone_SetBottomAttributeSet(cone, bottomAttributeSet));
1428 }
1429
1430
1431
1432
1433
1434 //=============================================================================
1435 // Q3Cone_GetBottomAttributeSet : Quesa API entry point.
1436 //-----------------------------------------------------------------------------
1437 TQ3Status
Q3Cone_GetBottomAttributeSet(TQ3GeometryObject cone,TQ3AttributeSet * bottomAttributeSet)1438 Q3Cone_GetBottomAttributeSet(TQ3GeometryObject cone, TQ3AttributeSet *bottomAttributeSet)
1439 {
1440
1441
1442 // Release build checks
1443 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1444 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(bottomAttributeSet), kQ3Failure);
1445
1446
1447
1448 // Debug build checks
1449 #if Q3_DEBUG
1450 if (0) // Further checks on cone
1451 return(kQ3Failure);
1452
1453 if (0) // Further checks on bottomAttributeSet
1454 return(kQ3Failure);
1455 #endif
1456
1457
1458
1459 // Call the bottleneck
1460 E3System_Bottleneck();
1461
1462
1463
1464 // Call our implementation
1465 return(E3Cone_GetBottomAttributeSet(cone, bottomAttributeSet));
1466 }
1467
1468
1469
1470
1471
1472 //=============================================================================
1473 // Q3Cone_SetFaceAttributeSet : Quesa API entry point.
1474 //-----------------------------------------------------------------------------
1475 TQ3Status
Q3Cone_SetFaceAttributeSet(TQ3GeometryObject cone,TQ3AttributeSet faceAttributeSet)1476 Q3Cone_SetFaceAttributeSet(TQ3GeometryObject cone, TQ3AttributeSet faceAttributeSet)
1477 {
1478
1479
1480 // Release build checks
1481 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1482
1483
1484
1485 // Debug build checks
1486 #if Q3_DEBUG
1487 if (0) // Further checks on cone
1488 return(kQ3Failure);
1489
1490 if (0) // Further checks on faceAttributeSet
1491 return(kQ3Failure);
1492 #endif
1493
1494
1495
1496 // Call the bottleneck
1497 E3System_Bottleneck();
1498
1499
1500
1501 // Call our implementation
1502 return(E3Cone_SetFaceAttributeSet(cone, faceAttributeSet));
1503 }
1504
1505
1506
1507
1508
1509 //=============================================================================
1510 // Q3Cone_GetFaceAttributeSet : Quesa API entry point.
1511 //-----------------------------------------------------------------------------
1512 TQ3Status
Q3Cone_GetFaceAttributeSet(TQ3GeometryObject cone,TQ3AttributeSet * faceAttributeSet)1513 Q3Cone_GetFaceAttributeSet(TQ3GeometryObject cone, TQ3AttributeSet *faceAttributeSet)
1514 {
1515
1516
1517 // Release build checks
1518 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cone ), kQ3Failure);
1519 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(faceAttributeSet), kQ3Failure);
1520
1521
1522
1523 // Debug build checks
1524 #if Q3_DEBUG
1525 if (0) // Further checks on cone
1526 return(kQ3Failure);
1527
1528 if (0) // Further checks on faceAttributeSet
1529 return(kQ3Failure);
1530 #endif
1531
1532
1533
1534 // Call the bottleneck
1535 E3System_Bottleneck();
1536
1537
1538
1539 // Call our implementation
1540 return(E3Cone_GetFaceAttributeSet(cone, faceAttributeSet));
1541 }
1542
1543
1544
1545
1546
1547 //=============================================================================
1548 // Q3Cone_SetInteriorAttributeSet : Quesa API entry point.
1549 //-----------------------------------------------------------------------------
1550 TQ3Status
Q3Cone_SetInteriorAttributeSet(TQ3GeometryObject cone,TQ3AttributeSet intAttributeSet)1551 Q3Cone_SetInteriorAttributeSet(TQ3GeometryObject cone, TQ3AttributeSet intAttributeSet)
1552 {
1553
1554
1555 // Release build checks
1556 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(cone, (kQ3GeometryTypeCone)), kQ3Failure);
1557
1558
1559
1560 // Debug build checks
1561 #if Q3_DEBUG
1562 if (0) // Further checks on cylinder
1563 return(kQ3Failure);
1564
1565 if (0) // Further checks on faceAttributeSet
1566 return(kQ3Failure);
1567 #endif
1568
1569
1570
1571 // Call the bottleneck
1572 E3System_Bottleneck();
1573
1574
1575
1576 // Call our implementation
1577 return(E3Cylinder_SetInteriorAttributeSet(cone, intAttributeSet));
1578 }
1579
1580
1581
1582
1583
1584 //=============================================================================
1585 // Q3Cone_GetInteriorAttributeSet : Quesa API entry point.
1586 //-----------------------------------------------------------------------------
1587 TQ3Status
Q3Cone_GetInteriorAttributeSet(TQ3GeometryObject cone,TQ3AttributeSet * intAttributeSet)1588 Q3Cone_GetInteriorAttributeSet(TQ3GeometryObject cone, TQ3AttributeSet *intAttributeSet)
1589 {
1590
1591
1592 // Release build checks
1593 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(cone, (kQ3GeometryTypeCone)), kQ3Failure);
1594 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(intAttributeSet), kQ3Failure);
1595
1596
1597
1598 // Debug build checks
1599 #if Q3_DEBUG
1600 if (0) // Further checks on cylinder
1601 return(kQ3Failure);
1602
1603 if (0) // Further checks on faceAttributeSet
1604 return(kQ3Failure);
1605 #endif
1606
1607
1608
1609 // Call the bottleneck
1610 E3System_Bottleneck();
1611
1612
1613
1614 // Call our implementation
1615 return(E3Cone_GetInteriorAttributeSet(cone, intAttributeSet));
1616 }
1617
1618
1619
1620
1621
1622 //=============================================================================
1623 // Q3Cone_EmptyData : Quesa API entry point.
1624 //-----------------------------------------------------------------------------
1625 TQ3Status
Q3Cone_EmptyData(TQ3ConeData * coneData)1626 Q3Cone_EmptyData(TQ3ConeData *coneData)
1627 {
1628
1629
1630 // Release build checks
1631 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coneData), kQ3Failure);
1632
1633
1634
1635 // Debug build checks
1636 #if Q3_DEBUG
1637 if (0) // Further checks on coneData
1638 return(kQ3Failure);
1639 #endif
1640
1641
1642
1643 // Call the bottleneck
1644 E3System_Bottleneck();
1645
1646
1647
1648 // Call our implementation
1649 return(E3Cone_EmptyData(coneData));
1650 }
1651
1652
1653
1654
1655
1656 //=============================================================================
1657 // Q3Cylinder_New : Quesa API entry point.
1658 //-----------------------------------------------------------------------------
1659 TQ3GeometryObject
Q3Cylinder_New(const TQ3CylinderData * cylinderData)1660 Q3Cylinder_New(const TQ3CylinderData *cylinderData)
1661 {
1662
1663
1664 // Release build checks
1665 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(cylinderData) || (cylinderData == NULL), NULL);
1666
1667
1668
1669 // Debug build checks
1670 #if Q3_DEBUG
1671 if (0) // Further checks on cylinderData
1672 return(NULL);
1673 #endif
1674
1675
1676
1677 // Call the bottleneck
1678 E3System_Bottleneck();
1679
1680
1681
1682 // Call our implementation
1683 return(E3Cylinder_New(cylinderData));
1684 }
1685
1686
1687
1688
1689
1690 //=============================================================================
1691 // Q3Cylinder_Submit : Quesa API entry point.
1692 //-----------------------------------------------------------------------------
1693 TQ3Status
Q3Cylinder_Submit(const TQ3CylinderData * cylinderData,TQ3ViewObject view)1694 Q3Cylinder_Submit(const TQ3CylinderData *cylinderData, TQ3ViewObject view)
1695 {
1696
1697
1698 // Release build checks
1699 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(cylinderData), kQ3Failure);
1700 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
1701
1702
1703
1704 // Debug build checks
1705 #if Q3_DEBUG
1706 if (0) // Further checks on cylinderData
1707 return(kQ3Failure);
1708
1709 if (0) // Further checks on view
1710 return(kQ3Failure);
1711 #endif
1712
1713
1714
1715 // Call the bottleneck
1716 E3System_Bottleneck();
1717
1718
1719
1720 // Call our implementation
1721 return(E3Cylinder_Submit(cylinderData, view));
1722 }
1723
1724
1725
1726
1727
1728 //=============================================================================
1729 // Q3Cylinder_SetData : Quesa API entry point.
1730 //-----------------------------------------------------------------------------
1731 TQ3Status
Q3Cylinder_SetData(TQ3GeometryObject cylinder,const TQ3CylinderData * cylinderData)1732 Q3Cylinder_SetData(TQ3GeometryObject cylinder, const TQ3CylinderData *cylinderData)
1733 {
1734
1735
1736 // Release build checks
1737 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1738 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(cylinderData), kQ3Failure);
1739
1740
1741
1742 // Debug build checks
1743 #if Q3_DEBUG
1744 if (0) // Further checks on cylinder
1745 return(kQ3Failure);
1746
1747 if (0) // Further checks on cylinderData
1748 return(kQ3Failure);
1749 #endif
1750
1751
1752
1753 // Call the bottleneck
1754 E3System_Bottleneck();
1755
1756
1757
1758 // Call our implementation
1759 return(E3Cylinder_SetData(cylinder, cylinderData));
1760 }
1761
1762
1763
1764
1765
1766 //=============================================================================
1767 // Q3Cylinder_GetData : Quesa API entry point.
1768 //-----------------------------------------------------------------------------
1769 TQ3Status
Q3Cylinder_GetData(TQ3GeometryObject cylinder,TQ3CylinderData * cylinderData)1770 Q3Cylinder_GetData(TQ3GeometryObject cylinder, TQ3CylinderData *cylinderData)
1771 {
1772
1773
1774 // Release build checks
1775 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1776 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(cylinderData), kQ3Failure);
1777
1778
1779
1780 // Debug build checks
1781 #if Q3_DEBUG
1782 if (0) // Further checks on cylinder
1783 return(kQ3Failure);
1784
1785 if (0) // Further checks on cylinderData
1786 return(kQ3Failure);
1787 #endif
1788
1789
1790
1791 // Call the bottleneck
1792 E3System_Bottleneck();
1793
1794
1795
1796 // Call our implementation
1797 return(E3Cylinder_GetData(cylinder, cylinderData));
1798 }
1799
1800
1801
1802
1803
1804 //=============================================================================
1805 // Q3Cylinder_SetOrigin : Quesa API entry point.
1806 //-----------------------------------------------------------------------------
1807 TQ3Status
Q3Cylinder_SetOrigin(TQ3GeometryObject cylinder,const TQ3Point3D * origin)1808 Q3Cylinder_SetOrigin(TQ3GeometryObject cylinder, const TQ3Point3D *origin)
1809 {
1810
1811
1812 // Release build checks
1813 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1814 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
1815
1816
1817
1818 // Debug build checks
1819 #if Q3_DEBUG
1820 if (0) // Further checks on cylinder
1821 return(kQ3Failure);
1822
1823 if (0) // Further checks on origin
1824 return(kQ3Failure);
1825 #endif
1826
1827
1828
1829 // Call the bottleneck
1830 E3System_Bottleneck();
1831
1832
1833
1834 // Call our implementation
1835 return(E3Cylinder_SetOrigin(cylinder, origin));
1836 }
1837
1838
1839
1840
1841
1842 //=============================================================================
1843 // Q3Cylinder_SetOrientation : Quesa API entry point.
1844 //-----------------------------------------------------------------------------
1845 TQ3Status
Q3Cylinder_SetOrientation(TQ3GeometryObject cylinder,const TQ3Vector3D * orientation)1846 Q3Cylinder_SetOrientation(TQ3GeometryObject cylinder, const TQ3Vector3D *orientation)
1847 {
1848
1849
1850 // Release build checks
1851 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1852 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
1853
1854
1855
1856 // Debug build checks
1857 #if Q3_DEBUG
1858 if (0) // Further checks on cylinder
1859 return(kQ3Failure);
1860
1861 if (0) // Further checks on orientation
1862 return(kQ3Failure);
1863 #endif
1864
1865
1866
1867 // Call the bottleneck
1868 E3System_Bottleneck();
1869
1870
1871
1872 // Call our implementation
1873 return(E3Cylinder_SetOrientation(cylinder, orientation));
1874 }
1875
1876
1877
1878
1879
1880 //=============================================================================
1881 // Q3Cylinder_SetMajorRadius : Quesa API entry point.
1882 //-----------------------------------------------------------------------------
1883 TQ3Status
Q3Cylinder_SetMajorRadius(TQ3GeometryObject cylinder,const TQ3Vector3D * majorRadius)1884 Q3Cylinder_SetMajorRadius(TQ3GeometryObject cylinder, const TQ3Vector3D *majorRadius)
1885 {
1886
1887
1888 // Release build checks
1889 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1890 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
1891
1892
1893
1894 // Debug build checks
1895 #if Q3_DEBUG
1896 if (0) // Further checks on cylinder
1897 return(kQ3Failure);
1898
1899 if (0) // Further checks on majorRadius
1900 return(kQ3Failure);
1901 #endif
1902
1903
1904
1905 // Call the bottleneck
1906 E3System_Bottleneck();
1907
1908
1909
1910 // Call our implementation
1911 return(E3Cylinder_SetMajorRadius(cylinder, majorRadius));
1912 }
1913
1914
1915
1916
1917
1918 //=============================================================================
1919 // Q3Cylinder_SetMinorRadius : Quesa API entry point.
1920 //-----------------------------------------------------------------------------
1921 TQ3Status
Q3Cylinder_SetMinorRadius(TQ3GeometryObject cylinder,const TQ3Vector3D * minorRadius)1922 Q3Cylinder_SetMinorRadius(TQ3GeometryObject cylinder, const TQ3Vector3D *minorRadius)
1923 {
1924
1925
1926 // Release build checks
1927 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1928 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
1929
1930
1931
1932 // Debug build checks
1933 #if Q3_DEBUG
1934 if (0) // Further checks on cylinder
1935 return(kQ3Failure);
1936
1937 if (0) // Further checks on minorRadius
1938 return(kQ3Failure);
1939 #endif
1940
1941
1942
1943 // Call the bottleneck
1944 E3System_Bottleneck();
1945
1946
1947
1948 // Call our implementation
1949 return(E3Cylinder_SetMinorRadius(cylinder, minorRadius));
1950 }
1951
1952
1953
1954
1955
1956 //=============================================================================
1957 // Q3Cylinder_GetOrigin : Quesa API entry point.
1958 //-----------------------------------------------------------------------------
1959 TQ3Status
Q3Cylinder_GetOrigin(TQ3GeometryObject cylinder,TQ3Point3D * origin)1960 Q3Cylinder_GetOrigin(TQ3GeometryObject cylinder, TQ3Point3D *origin)
1961 {
1962
1963
1964 // Release build checks
1965 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
1966 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
1967
1968
1969
1970 // Debug build checks
1971 #if Q3_DEBUG
1972 if (0) // Further checks on cylinder
1973 return(kQ3Failure);
1974
1975 if (0) // Further checks on origin
1976 return(kQ3Failure);
1977 #endif
1978
1979
1980
1981 // Call the bottleneck
1982 E3System_Bottleneck();
1983
1984
1985
1986 // Call our implementation
1987 return(E3Cylinder_GetOrigin(cylinder, origin));
1988 }
1989
1990
1991
1992
1993
1994 //=============================================================================
1995 // Q3Cylinder_GetOrientation : Quesa API entry point.
1996 //-----------------------------------------------------------------------------
1997 TQ3Status
Q3Cylinder_GetOrientation(TQ3GeometryObject cylinder,TQ3Vector3D * orientation)1998 Q3Cylinder_GetOrientation(TQ3GeometryObject cylinder, TQ3Vector3D *orientation)
1999 {
2000
2001
2002 // Release build checks
2003 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2004 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
2005
2006
2007
2008 // Debug build checks
2009 #if Q3_DEBUG
2010 if (0) // Further checks on cylinder
2011 return(kQ3Failure);
2012
2013 if (0) // Further checks on orientation
2014 return(kQ3Failure);
2015 #endif
2016
2017
2018
2019 // Call the bottleneck
2020 E3System_Bottleneck();
2021
2022
2023
2024 // Call our implementation
2025 return(E3Cylinder_GetOrientation(cylinder, orientation));
2026 }
2027
2028
2029
2030
2031
2032 //=============================================================================
2033 // Q3Cylinder_GetMajorRadius : Quesa API entry point.
2034 //-----------------------------------------------------------------------------
2035 TQ3Status
Q3Cylinder_GetMajorRadius(TQ3GeometryObject cylinder,TQ3Vector3D * majorRadius)2036 Q3Cylinder_GetMajorRadius(TQ3GeometryObject cylinder, TQ3Vector3D *majorRadius)
2037 {
2038
2039
2040 // Release build checks
2041 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2042 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
2043
2044
2045
2046 // Debug build checks
2047 #if Q3_DEBUG
2048 if (0) // Further checks on cylinder
2049 return(kQ3Failure);
2050
2051 if (0) // Further checks on majorRadius
2052 return(kQ3Failure);
2053 #endif
2054
2055
2056
2057 // Call the bottleneck
2058 E3System_Bottleneck();
2059
2060
2061
2062 // Call our implementation
2063 return(E3Cylinder_GetMajorRadius(cylinder, majorRadius));
2064 }
2065
2066
2067
2068
2069
2070 //=============================================================================
2071 // Q3Cylinder_GetMinorRadius : Quesa API entry point.
2072 //-----------------------------------------------------------------------------
2073 TQ3Status
Q3Cylinder_GetMinorRadius(TQ3GeometryObject cylinder,TQ3Vector3D * minorRadius)2074 Q3Cylinder_GetMinorRadius(TQ3GeometryObject cylinder, TQ3Vector3D *minorRadius)
2075 {
2076
2077
2078 // Release build checks
2079 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2080 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
2081
2082
2083
2084 // Debug build checks
2085 #if Q3_DEBUG
2086 if (0) // Further checks on cylinder
2087 return(kQ3Failure);
2088
2089 if (0) // Further checks on minorRadius
2090 return(kQ3Failure);
2091 #endif
2092
2093
2094
2095 // Call the bottleneck
2096 E3System_Bottleneck();
2097
2098
2099
2100 // Call our implementation
2101 return(E3Cylinder_GetMinorRadius(cylinder, minorRadius));
2102 }
2103
2104
2105
2106
2107
2108 //=============================================================================
2109 // Q3Cylinder_SetCaps : Quesa API entry point.
2110 //-----------------------------------------------------------------------------
2111 TQ3Status
Q3Cylinder_SetCaps(TQ3GeometryObject cylinder,TQ3EndCap caps)2112 Q3Cylinder_SetCaps(TQ3GeometryObject cylinder, TQ3EndCap caps)
2113 {
2114
2115
2116 // Release build checks
2117 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2118
2119
2120
2121 // Debug build checks
2122 #if Q3_DEBUG
2123 if (0) // Further checks on cylinder
2124 return(kQ3Failure);
2125
2126 if (0) // Further checks on caps
2127 return(kQ3Failure);
2128 #endif
2129
2130
2131
2132 // Call the bottleneck
2133 E3System_Bottleneck();
2134
2135
2136
2137 // Call our implementation
2138 return(E3Cylinder_SetCaps(cylinder, caps));
2139 }
2140
2141
2142
2143
2144
2145 //=============================================================================
2146 // Q3Cylinder_GetCaps : Quesa API entry point.
2147 //-----------------------------------------------------------------------------
2148 TQ3Status
Q3Cylinder_GetCaps(TQ3GeometryObject cylinder,TQ3EndCap * caps)2149 Q3Cylinder_GetCaps(TQ3GeometryObject cylinder, TQ3EndCap *caps)
2150 {
2151
2152
2153 // Release build checks
2154 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2155 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(caps), kQ3Failure);
2156
2157
2158
2159 // Debug build checks
2160 #if Q3_DEBUG
2161 if (0) // Further checks on cylinder
2162 return(kQ3Failure);
2163
2164 if (0) // Further checks on caps
2165 return(kQ3Failure);
2166 #endif
2167
2168
2169
2170 // Call the bottleneck
2171 E3System_Bottleneck();
2172
2173
2174
2175 // Call our implementation
2176 return(E3Cylinder_GetCaps(cylinder, caps));
2177 }
2178
2179
2180
2181
2182
2183 //=============================================================================
2184 // Q3Cylinder_SetTopAttributeSet : Quesa API entry point.
2185 //-----------------------------------------------------------------------------
2186 TQ3Status
Q3Cylinder_SetTopAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet topAttributeSet)2187 Q3Cylinder_SetTopAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet topAttributeSet)
2188 {
2189
2190
2191 // Release build checks
2192 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2193
2194
2195
2196 // Debug build checks
2197 #if Q3_DEBUG
2198 if (0) // Further checks on cylinder
2199 return(kQ3Failure);
2200
2201 if (0) // Further checks on topAttributeSet
2202 return(kQ3Failure);
2203 #endif
2204
2205
2206
2207 // Call the bottleneck
2208 E3System_Bottleneck();
2209
2210
2211
2212 // Call our implementation
2213 return(E3Cylinder_SetTopAttributeSet(cylinder, topAttributeSet));
2214 }
2215
2216
2217
2218
2219
2220 //=============================================================================
2221 // Q3Cylinder_GetTopAttributeSet : Quesa API entry point.
2222 //-----------------------------------------------------------------------------
2223 TQ3Status
Q3Cylinder_GetTopAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet * topAttributeSet)2224 Q3Cylinder_GetTopAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet *topAttributeSet)
2225 {
2226
2227
2228 // Release build checks
2229 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2230 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(topAttributeSet), kQ3Failure);
2231
2232
2233
2234 // Debug build checks
2235 #if Q3_DEBUG
2236 if (0) // Further checks on cylinder
2237 return(kQ3Failure);
2238
2239 if (0) // Further checks on topAttributeSet
2240 return(kQ3Failure);
2241 #endif
2242
2243
2244
2245 // Call the bottleneck
2246 E3System_Bottleneck();
2247
2248
2249
2250 // Call our implementation
2251 return(E3Cylinder_GetTopAttributeSet(cylinder, topAttributeSet));
2252 }
2253
2254
2255
2256
2257
2258 //=============================================================================
2259 // Q3Cylinder_SetBottomAttributeSet : Quesa API entry point.
2260 //-----------------------------------------------------------------------------
2261 TQ3Status
Q3Cylinder_SetBottomAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet bottomAttributeSet)2262 Q3Cylinder_SetBottomAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet bottomAttributeSet)
2263 {
2264
2265
2266 // Release build checks
2267 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2268
2269
2270
2271 // Debug build checks
2272 #if Q3_DEBUG
2273 if (0) // Further checks on cylinder
2274 return(kQ3Failure);
2275
2276 if (0) // Further checks on bottomAttributeSet
2277 return(kQ3Failure);
2278 #endif
2279
2280
2281
2282 // Call the bottleneck
2283 E3System_Bottleneck();
2284
2285
2286
2287 // Call our implementation
2288 return(E3Cylinder_SetBottomAttributeSet(cylinder, bottomAttributeSet));
2289 }
2290
2291
2292
2293
2294
2295 //=============================================================================
2296 // Q3Cylinder_GetBottomAttributeSet : Quesa API entry point.
2297 //-----------------------------------------------------------------------------
2298 TQ3Status
Q3Cylinder_GetBottomAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet * bottomAttributeSet)2299 Q3Cylinder_GetBottomAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet *bottomAttributeSet)
2300 {
2301
2302
2303 // Release build checks
2304 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2305 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(bottomAttributeSet), kQ3Failure);
2306
2307
2308
2309 // Debug build checks
2310 #if Q3_DEBUG
2311 if (0) // Further checks on cylinder
2312 return(kQ3Failure);
2313
2314 if (0) // Further checks on bottomAttributeSet
2315 return(kQ3Failure);
2316 #endif
2317
2318
2319
2320 // Call the bottleneck
2321 E3System_Bottleneck();
2322
2323
2324
2325 // Call our implementation
2326 return(E3Cylinder_GetBottomAttributeSet(cylinder, bottomAttributeSet));
2327 }
2328
2329
2330
2331
2332
2333 //=============================================================================
2334 // Q3Cylinder_SetFaceAttributeSet : Quesa API entry point.
2335 //-----------------------------------------------------------------------------
2336 TQ3Status
Q3Cylinder_SetFaceAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet faceAttributeSet)2337 Q3Cylinder_SetFaceAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet faceAttributeSet)
2338 {
2339
2340
2341 // Release build checks
2342 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2343
2344
2345
2346 // Debug build checks
2347 #if Q3_DEBUG
2348 if (0) // Further checks on cylinder
2349 return(kQ3Failure);
2350
2351 if (0) // Further checks on faceAttributeSet
2352 return(kQ3Failure);
2353 #endif
2354
2355
2356
2357 // Call the bottleneck
2358 E3System_Bottleneck();
2359
2360
2361
2362 // Call our implementation
2363 return(E3Cylinder_SetFaceAttributeSet(cylinder, faceAttributeSet));
2364 }
2365
2366
2367
2368
2369
2370 //=============================================================================
2371 // Q3Cylinder_GetFaceAttributeSet : Quesa API entry point.
2372 //-----------------------------------------------------------------------------
2373 TQ3Status
Q3Cylinder_GetFaceAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet * faceAttributeSet)2374 Q3Cylinder_GetFaceAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet *faceAttributeSet)
2375 {
2376
2377
2378 // Release build checks
2379 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2380 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(faceAttributeSet), kQ3Failure);
2381
2382
2383
2384 // Debug build checks
2385 #if Q3_DEBUG
2386 if (0) // Further checks on cylinder
2387 return(kQ3Failure);
2388
2389 if (0) // Further checks on faceAttributeSet
2390 return(kQ3Failure);
2391 #endif
2392
2393
2394
2395 // Call the bottleneck
2396 E3System_Bottleneck();
2397
2398
2399
2400 // Call our implementation
2401 return(E3Cylinder_GetFaceAttributeSet(cylinder, faceAttributeSet));
2402 }
2403
2404
2405
2406
2407
2408 //=============================================================================
2409 // Q3Cylinder_SetInteriorAttributeSet : Quesa API entry point.
2410 //-----------------------------------------------------------------------------
2411 TQ3Status
Q3Cylinder_SetInteriorAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet intAttributeSet)2412 Q3Cylinder_SetInteriorAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet intAttributeSet)
2413 {
2414
2415
2416 // Release build checks
2417 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2418
2419
2420
2421 // Debug build checks
2422 #if Q3_DEBUG
2423 if (0) // Further checks on cylinder
2424 return(kQ3Failure);
2425
2426 if (0) // Further checks on faceAttributeSet
2427 return(kQ3Failure);
2428 #endif
2429
2430
2431
2432 // Call the bottleneck
2433 E3System_Bottleneck();
2434
2435
2436
2437 // Call our implementation
2438 return(E3Cylinder_SetInteriorAttributeSet(cylinder, intAttributeSet));
2439 }
2440
2441
2442
2443
2444
2445 //=============================================================================
2446 // Q3Cylinder_GetInteriorAttributeSet : Quesa API entry point.
2447 //-----------------------------------------------------------------------------
2448 TQ3Status
Q3Cylinder_GetInteriorAttributeSet(TQ3GeometryObject cylinder,TQ3AttributeSet * intAttributeSet)2449 Q3Cylinder_GetInteriorAttributeSet(TQ3GeometryObject cylinder, TQ3AttributeSet *intAttributeSet)
2450 {
2451
2452
2453 // Release build checks
2454 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( cylinder ), kQ3Failure);
2455 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(intAttributeSet), kQ3Failure);
2456
2457
2458
2459 // Debug build checks
2460 #if Q3_DEBUG
2461 if (0) // Further checks on cylinder
2462 return(kQ3Failure);
2463
2464 if (0) // Further checks on faceAttributeSet
2465 return(kQ3Failure);
2466 #endif
2467
2468
2469
2470 // Call the bottleneck
2471 E3System_Bottleneck();
2472
2473
2474
2475 // Call our implementation
2476 return(E3Cylinder_GetInteriorAttributeSet(cylinder, intAttributeSet));
2477 }
2478
2479
2480
2481
2482
2483 //=============================================================================
2484 // Q3Cylinder_EmptyData : Quesa API entry point.
2485 //-----------------------------------------------------------------------------
2486 TQ3Status
Q3Cylinder_EmptyData(TQ3CylinderData * cylinderData)2487 Q3Cylinder_EmptyData(TQ3CylinderData *cylinderData)
2488 {
2489
2490
2491 // Release build checks
2492 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(cylinderData), kQ3Failure);
2493
2494
2495
2496 // Debug build checks
2497 #if Q3_DEBUG
2498 if (0) // Further checks on cylinderData
2499 return(kQ3Failure);
2500 #endif
2501
2502
2503
2504 // Call the bottleneck
2505 E3System_Bottleneck();
2506
2507
2508
2509 // Call our implementation
2510 return(E3Cylinder_EmptyData(cylinderData));
2511 }
2512
2513
2514
2515
2516
2517 //=============================================================================
2518 // Q3Disk_New : Quesa API entry point.
2519 //-----------------------------------------------------------------------------
2520 TQ3GeometryObject
Q3Disk_New(const TQ3DiskData * diskData)2521 Q3Disk_New(const TQ3DiskData *diskData)
2522 {
2523
2524
2525 // Release build checks
2526 Q3_REQUIRE_OR_RESULT( (diskData == NULL) || Q3_VALID_PTR(diskData), NULL);
2527
2528
2529
2530 // Debug build checks
2531 #if Q3_DEBUG
2532 if (0) // Further checks on diskData
2533 return(NULL);
2534 #endif
2535
2536
2537
2538 // Call the bottleneck
2539 E3System_Bottleneck();
2540
2541
2542
2543 // Call our implementation
2544 return(E3Disk_New(diskData));
2545 }
2546
2547
2548
2549
2550
2551 //=============================================================================
2552 // Q3Disk_Submit : Quesa API entry point.
2553 //-----------------------------------------------------------------------------
2554 TQ3Status
Q3Disk_Submit(const TQ3DiskData * diskData,TQ3ViewObject view)2555 Q3Disk_Submit(const TQ3DiskData *diskData, TQ3ViewObject view)
2556 {
2557
2558
2559 // Release build checks
2560 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(diskData), kQ3Failure);
2561 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
2562
2563
2564
2565 // Debug build checks
2566 #if Q3_DEBUG
2567 if (0) // Further checks on diskData
2568 return(kQ3Failure);
2569
2570 if (0) // Further checks on view
2571 return(kQ3Failure);
2572 #endif
2573
2574
2575
2576 // Call the bottleneck
2577 E3System_Bottleneck();
2578
2579
2580
2581 // Call our implementation
2582 return(E3Disk_Submit(diskData, view));
2583 }
2584
2585
2586
2587
2588
2589 //=============================================================================
2590 // Q3Disk_SetData : Quesa API entry point.
2591 //-----------------------------------------------------------------------------
2592 TQ3Status
Q3Disk_SetData(TQ3GeometryObject disk,const TQ3DiskData * diskData)2593 Q3Disk_SetData(TQ3GeometryObject disk, const TQ3DiskData *diskData)
2594 {
2595
2596
2597 // Release build checks
2598 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2599 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(diskData), kQ3Failure);
2600
2601
2602
2603 // Debug build checks
2604 #if Q3_DEBUG
2605 if (0) // Further checks on disk
2606 return(kQ3Failure);
2607
2608 if (0) // Further checks on diskData
2609 return(kQ3Failure);
2610 #endif
2611
2612
2613
2614 // Call the bottleneck
2615 E3System_Bottleneck();
2616
2617
2618
2619 // Call our implementation
2620 return(E3Disk_SetData(disk, diskData));
2621 }
2622
2623
2624
2625
2626
2627 //=============================================================================
2628 // Q3Disk_GetData : Quesa API entry point.
2629 //-----------------------------------------------------------------------------
2630 TQ3Status
Q3Disk_GetData(TQ3GeometryObject disk,TQ3DiskData * diskData)2631 Q3Disk_GetData(TQ3GeometryObject disk, TQ3DiskData *diskData)
2632 {
2633
2634
2635 // Release build checks
2636 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2637 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(diskData), kQ3Failure);
2638
2639
2640
2641 // Debug build checks
2642 #if Q3_DEBUG
2643 if (0) // Further checks on disk
2644 return(kQ3Failure);
2645
2646 if (0) // Further checks on diskData
2647 return(kQ3Failure);
2648 #endif
2649
2650
2651
2652 // Call the bottleneck
2653 E3System_Bottleneck();
2654
2655
2656
2657 // Call our implementation
2658 return(E3Disk_GetData(disk, diskData));
2659 }
2660
2661
2662
2663
2664
2665 //=============================================================================
2666 // Q3Disk_SetOrigin : Quesa API entry point.
2667 //-----------------------------------------------------------------------------
2668 TQ3Status
Q3Disk_SetOrigin(TQ3GeometryObject disk,const TQ3Point3D * origin)2669 Q3Disk_SetOrigin(TQ3GeometryObject disk, const TQ3Point3D *origin)
2670 {
2671
2672
2673 // Release build checks
2674 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2675 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
2676
2677
2678
2679 // Debug build checks
2680 #if Q3_DEBUG
2681 if (0) // Further checks on disk
2682 return(kQ3Failure);
2683
2684 if (0) // Further checks on origin
2685 return(kQ3Failure);
2686 #endif
2687
2688
2689
2690 // Call the bottleneck
2691 E3System_Bottleneck();
2692
2693
2694
2695 // Call our implementation
2696 return(E3Disk_SetOrigin(disk, origin));
2697 }
2698
2699
2700
2701
2702
2703 //=============================================================================
2704 // Q3Disk_SetMajorRadius : Quesa API entry point.
2705 //-----------------------------------------------------------------------------
2706 TQ3Status
Q3Disk_SetMajorRadius(TQ3GeometryObject disk,const TQ3Vector3D * majorRadius)2707 Q3Disk_SetMajorRadius(TQ3GeometryObject disk, const TQ3Vector3D *majorRadius)
2708 {
2709
2710
2711 // Release build checks
2712 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2713 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
2714
2715
2716
2717 // Debug build checks
2718 #if Q3_DEBUG
2719 if (0) // Further checks on disk
2720 return(kQ3Failure);
2721
2722 if (0) // Further checks on majorRadius
2723 return(kQ3Failure);
2724 #endif
2725
2726
2727
2728 // Call the bottleneck
2729 E3System_Bottleneck();
2730
2731
2732
2733 // Call our implementation
2734 return(E3Disk_SetMajorRadius(disk, majorRadius));
2735 }
2736
2737
2738
2739
2740
2741 //=============================================================================
2742 // Q3Disk_SetMinorRadius : Quesa API entry point.
2743 //-----------------------------------------------------------------------------
2744 TQ3Status
Q3Disk_SetMinorRadius(TQ3GeometryObject disk,const TQ3Vector3D * minorRadius)2745 Q3Disk_SetMinorRadius(TQ3GeometryObject disk, const TQ3Vector3D *minorRadius)
2746 {
2747
2748
2749 // Release build checks
2750 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2751 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
2752
2753
2754
2755 // Debug build checks
2756 #if Q3_DEBUG
2757 if (0) // Further checks on disk
2758 return(kQ3Failure);
2759
2760 if (0) // Further checks on minorRadius
2761 return(kQ3Failure);
2762 #endif
2763
2764
2765
2766 // Call the bottleneck
2767 E3System_Bottleneck();
2768
2769
2770
2771 // Call our implementation
2772 return(E3Disk_SetMinorRadius(disk, minorRadius));
2773 }
2774
2775
2776
2777
2778
2779 //=============================================================================
2780 // Q3Disk_GetOrigin : Quesa API entry point.
2781 //-----------------------------------------------------------------------------
2782 TQ3Status
Q3Disk_GetOrigin(TQ3GeometryObject disk,TQ3Point3D * origin)2783 Q3Disk_GetOrigin(TQ3GeometryObject disk, TQ3Point3D *origin)
2784 {
2785
2786
2787 // Release build checks
2788 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2789 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
2790
2791
2792
2793 // Debug build checks
2794 #if Q3_DEBUG
2795 if (0) // Further checks on disk
2796 return(kQ3Failure);
2797
2798 if (0) // Further checks on origin
2799 return(kQ3Failure);
2800 #endif
2801
2802
2803
2804 // Call the bottleneck
2805 E3System_Bottleneck();
2806
2807
2808
2809 // Call our implementation
2810 return(E3Disk_GetOrigin(disk, origin));
2811 }
2812
2813
2814
2815
2816
2817 //=============================================================================
2818 // Q3Disk_GetMajorRadius : Quesa API entry point.
2819 //-----------------------------------------------------------------------------
2820 TQ3Status
Q3Disk_GetMajorRadius(TQ3GeometryObject disk,TQ3Vector3D * majorRadius)2821 Q3Disk_GetMajorRadius(TQ3GeometryObject disk, TQ3Vector3D *majorRadius)
2822 {
2823
2824
2825 // Release build checks
2826 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2827 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
2828
2829
2830
2831 // Debug build checks
2832 #if Q3_DEBUG
2833 if (0) // Further checks on disk
2834 return(kQ3Failure);
2835
2836 if (0) // Further checks on majorRadius
2837 return(kQ3Failure);
2838 #endif
2839
2840
2841
2842 // Call the bottleneck
2843 E3System_Bottleneck();
2844
2845
2846
2847 // Call our implementation
2848 return(E3Disk_GetMajorRadius(disk, majorRadius));
2849 }
2850
2851
2852
2853
2854
2855 //=============================================================================
2856 // Q3Disk_GetMinorRadius : Quesa API entry point.
2857 //-----------------------------------------------------------------------------
2858 TQ3Status
Q3Disk_GetMinorRadius(TQ3GeometryObject disk,TQ3Vector3D * minorRadius)2859 Q3Disk_GetMinorRadius(TQ3GeometryObject disk, TQ3Vector3D *minorRadius)
2860 {
2861
2862
2863 // Release build checks
2864 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( disk ), kQ3Failure);
2865 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
2866
2867
2868
2869 // Debug build checks
2870 #if Q3_DEBUG
2871 if (0) // Further checks on disk
2872 return(kQ3Failure);
2873
2874 if (0) // Further checks on minorRadius
2875 return(kQ3Failure);
2876 #endif
2877
2878
2879
2880 // Call the bottleneck
2881 E3System_Bottleneck();
2882
2883
2884
2885 // Call our implementation
2886 return(E3Disk_GetMinorRadius(disk, minorRadius));
2887 }
2888
2889
2890
2891
2892
2893 //=============================================================================
2894 // Q3Disk_EmptyData : Quesa API entry point.
2895 //-----------------------------------------------------------------------------
2896 TQ3Status
Q3Disk_EmptyData(TQ3DiskData * diskData)2897 Q3Disk_EmptyData(TQ3DiskData *diskData)
2898 {
2899
2900
2901 // Release build checks
2902 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(diskData), kQ3Failure);
2903
2904
2905
2906 // Debug build checks
2907 #if Q3_DEBUG
2908 if (0) // Further checks on diskData
2909 return(kQ3Failure);
2910 #endif
2911
2912
2913
2914 // Call the bottleneck
2915 E3System_Bottleneck();
2916
2917
2918
2919 // Call our implementation
2920 return(E3Disk_EmptyData(diskData));
2921 }
2922
2923
2924
2925
2926
2927 //=============================================================================
2928 // Q3Ellipse_New : Quesa API entry point.
2929 //-----------------------------------------------------------------------------
2930 TQ3GeometryObject
Q3Ellipse_New(const TQ3EllipseData * ellipseData)2931 Q3Ellipse_New(const TQ3EllipseData *ellipseData)
2932 {
2933
2934
2935 // Release build checks
2936 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipseData) || (ellipseData == NULL), NULL);
2937
2938
2939
2940 // Debug build checks
2941 #if Q3_DEBUG
2942 if (0) // Further checks on ellipseData
2943 return(NULL);
2944 #endif
2945
2946
2947
2948 // Call the bottleneck
2949 E3System_Bottleneck();
2950
2951
2952
2953 // Call our implementation
2954 return(E3Ellipse_New(ellipseData));
2955 }
2956
2957
2958
2959
2960
2961 //=============================================================================
2962 // Q3Ellipse_Submit : Quesa API entry point.
2963 //-----------------------------------------------------------------------------
2964 TQ3Status
Q3Ellipse_Submit(const TQ3EllipseData * ellipseData,TQ3ViewObject view)2965 Q3Ellipse_Submit(const TQ3EllipseData *ellipseData, TQ3ViewObject view)
2966 {
2967
2968
2969 // Release build checks
2970 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipseData), kQ3Failure);
2971 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
2972
2973
2974
2975 // Debug build checks
2976 #if Q3_DEBUG
2977 if (0) // Further checks on ellipseData
2978 return(kQ3Failure);
2979
2980 if (0) // Further checks on view
2981 return(kQ3Failure);
2982 #endif
2983
2984
2985
2986 // Call the bottleneck
2987 E3System_Bottleneck();
2988
2989
2990
2991 // Call our implementation
2992 return(E3Ellipse_Submit(ellipseData, view));
2993 }
2994
2995
2996
2997
2998
2999 //=============================================================================
3000 // Q3Ellipse_SetData : Quesa API entry point.
3001 //-----------------------------------------------------------------------------
3002 TQ3Status
Q3Ellipse_SetData(TQ3GeometryObject ellipse,const TQ3EllipseData * ellipseData)3003 Q3Ellipse_SetData(TQ3GeometryObject ellipse, const TQ3EllipseData *ellipseData)
3004 {
3005
3006
3007 // Release build checks
3008 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3009 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipseData), kQ3Failure);
3010
3011
3012
3013 // Debug build checks
3014 #if Q3_DEBUG
3015 if (0) // Further checks on ellipse
3016 return(kQ3Failure);
3017
3018 if (0) // Further checks on ellipseData
3019 return(kQ3Failure);
3020 #endif
3021
3022
3023
3024 // Call the bottleneck
3025 E3System_Bottleneck();
3026
3027
3028
3029 // Call our implementation
3030 return(E3Ellipse_SetData(ellipse, ellipseData));
3031 }
3032
3033
3034
3035
3036
3037 //=============================================================================
3038 // Q3Ellipse_GetData : Quesa API entry point.
3039 //-----------------------------------------------------------------------------
3040 TQ3Status
Q3Ellipse_GetData(TQ3GeometryObject ellipse,TQ3EllipseData * ellipseData)3041 Q3Ellipse_GetData(TQ3GeometryObject ellipse, TQ3EllipseData *ellipseData)
3042 {
3043
3044
3045 // Release build checks
3046 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3047 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipseData), kQ3Failure);
3048
3049
3050
3051 // Debug build checks
3052 #if Q3_DEBUG
3053 if (0) // Further checks on ellipse
3054 return(kQ3Failure);
3055
3056 if (0) // Further checks on ellipseData
3057 return(kQ3Failure);
3058 #endif
3059
3060
3061
3062 // Call the bottleneck
3063 E3System_Bottleneck();
3064
3065
3066
3067 // Call our implementation
3068 return(E3Ellipse_GetData(ellipse, ellipseData));
3069 }
3070
3071
3072
3073
3074
3075 //=============================================================================
3076 // Q3Ellipse_SetOrigin : Quesa API entry point.
3077 //-----------------------------------------------------------------------------
3078 TQ3Status
Q3Ellipse_SetOrigin(TQ3GeometryObject ellipse,const TQ3Point3D * origin)3079 Q3Ellipse_SetOrigin(TQ3GeometryObject ellipse, const TQ3Point3D *origin)
3080 {
3081
3082
3083 // Release build checks
3084 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3085 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
3086
3087
3088
3089 // Debug build checks
3090 #if Q3_DEBUG
3091 if (0) // Further checks on ellipse
3092 return(kQ3Failure);
3093
3094 if (0) // Further checks on origin
3095 return(kQ3Failure);
3096 #endif
3097
3098
3099
3100 // Call the bottleneck
3101 E3System_Bottleneck();
3102
3103
3104
3105 // Call our implementation
3106 return(E3Ellipse_SetOrigin(ellipse, origin));
3107 }
3108
3109
3110
3111
3112
3113 //=============================================================================
3114 // Q3Ellipse_SetMajorRadius : Quesa API entry point.
3115 //-----------------------------------------------------------------------------
3116 TQ3Status
Q3Ellipse_SetMajorRadius(TQ3GeometryObject ellipse,const TQ3Vector3D * majorRadius)3117 Q3Ellipse_SetMajorRadius(TQ3GeometryObject ellipse, const TQ3Vector3D *majorRadius)
3118 {
3119
3120
3121 // Release build checks
3122 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3123 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
3124
3125
3126
3127 // Debug build checks
3128 #if Q3_DEBUG
3129 if (0) // Further checks on ellipse
3130 return(kQ3Failure);
3131
3132 if (0) // Further checks on majorRadius
3133 return(kQ3Failure);
3134 #endif
3135
3136
3137
3138 // Call the bottleneck
3139 E3System_Bottleneck();
3140
3141
3142
3143 // Call our implementation
3144 return(E3Ellipse_SetMajorRadius(ellipse, majorRadius));
3145 }
3146
3147
3148
3149
3150
3151 //=============================================================================
3152 // Q3Ellipse_SetMinorRadius : Quesa API entry point.
3153 //-----------------------------------------------------------------------------
3154 TQ3Status
Q3Ellipse_SetMinorRadius(TQ3GeometryObject ellipse,const TQ3Vector3D * minorRadius)3155 Q3Ellipse_SetMinorRadius(TQ3GeometryObject ellipse, const TQ3Vector3D *minorRadius)
3156 {
3157
3158
3159 // Release build checks
3160 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3161 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
3162
3163
3164
3165 // Debug build checks
3166 #if Q3_DEBUG
3167 if (0) // Further checks on ellipse
3168 return(kQ3Failure);
3169
3170 if (0) // Further checks on minorRadius
3171 return(kQ3Failure);
3172 #endif
3173
3174
3175
3176 // Call the bottleneck
3177 E3System_Bottleneck();
3178
3179
3180
3181 // Call our implementation
3182 return(E3Ellipse_SetMinorRadius(ellipse, minorRadius));
3183 }
3184
3185
3186
3187
3188
3189 //=============================================================================
3190 // Q3Ellipse_GetOrigin : Quesa API entry point.
3191 //-----------------------------------------------------------------------------
3192 TQ3Status
Q3Ellipse_GetOrigin(TQ3GeometryObject ellipse,TQ3Point3D * origin)3193 Q3Ellipse_GetOrigin(TQ3GeometryObject ellipse, TQ3Point3D *origin)
3194 {
3195
3196
3197 // Release build checks
3198 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3199 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
3200
3201
3202
3203 // Debug build checks
3204 #if Q3_DEBUG
3205 if (0) // Further checks on ellipse
3206 return(kQ3Failure);
3207
3208 if (0) // Further checks on origin
3209 return(kQ3Failure);
3210 #endif
3211
3212
3213
3214 // Call the bottleneck
3215 E3System_Bottleneck();
3216
3217
3218
3219 // Call our implementation
3220 return(E3Ellipse_GetOrigin(ellipse, origin));
3221 }
3222
3223
3224
3225
3226
3227 //=============================================================================
3228 // Q3Ellipse_GetMajorRadius : Quesa API entry point.
3229 //-----------------------------------------------------------------------------
3230 TQ3Status
Q3Ellipse_GetMajorRadius(TQ3GeometryObject ellipse,TQ3Vector3D * majorRadius)3231 Q3Ellipse_GetMajorRadius(TQ3GeometryObject ellipse, TQ3Vector3D *majorRadius)
3232 {
3233
3234
3235 // Release build checks
3236 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3237 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
3238
3239
3240
3241 // Debug build checks
3242 #if Q3_DEBUG
3243 if (0) // Further checks on ellipse
3244 return(kQ3Failure);
3245
3246 if (0) // Further checks on majorRadius
3247 return(kQ3Failure);
3248 #endif
3249
3250
3251
3252 // Call the bottleneck
3253 E3System_Bottleneck();
3254
3255
3256
3257 // Call our implementation
3258 return(E3Ellipse_GetMajorRadius(ellipse, majorRadius));
3259 }
3260
3261
3262
3263
3264
3265 //=============================================================================
3266 // Q3Ellipse_GetMinorRadius : Quesa API entry point.
3267 //-----------------------------------------------------------------------------
3268 TQ3Status
Q3Ellipse_GetMinorRadius(TQ3GeometryObject ellipse,TQ3Vector3D * minorRadius)3269 Q3Ellipse_GetMinorRadius(TQ3GeometryObject ellipse, TQ3Vector3D *minorRadius)
3270 {
3271
3272
3273 // Release build checks
3274 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipse ), kQ3Failure);
3275 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
3276
3277
3278
3279 // Debug build checks
3280 #if Q3_DEBUG
3281 if (0) // Further checks on ellipse
3282 return(kQ3Failure);
3283
3284 if (0) // Further checks on minorRadius
3285 return(kQ3Failure);
3286 #endif
3287
3288
3289
3290 // Call the bottleneck
3291 E3System_Bottleneck();
3292
3293
3294
3295 // Call our implementation
3296 return(E3Ellipse_GetMinorRadius(ellipse, minorRadius));
3297 }
3298
3299
3300
3301
3302
3303 //=============================================================================
3304 // Q3Ellipse_EmptyData : Quesa API entry point.
3305 //-----------------------------------------------------------------------------
3306 TQ3Status
Q3Ellipse_EmptyData(TQ3EllipseData * ellipseData)3307 Q3Ellipse_EmptyData(TQ3EllipseData *ellipseData)
3308 {
3309
3310
3311 // Release build checks
3312 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipseData), kQ3Failure);
3313
3314
3315
3316 // Debug build checks
3317 #if Q3_DEBUG
3318 if (0) // Further checks on ellipseData
3319 return(kQ3Failure);
3320 #endif
3321
3322
3323
3324 // Call the bottleneck
3325 E3System_Bottleneck();
3326
3327
3328
3329 // Call our implementation
3330 return(E3Ellipse_EmptyData(ellipseData));
3331 }
3332
3333
3334
3335
3336
3337 //=============================================================================
3338 // Q3Ellipsoid_New : Quesa API entry point.
3339 //-----------------------------------------------------------------------------
3340 TQ3GeometryObject
Q3Ellipsoid_New(const TQ3EllipsoidData * ellipsoidData)3341 Q3Ellipsoid_New(const TQ3EllipsoidData *ellipsoidData)
3342 {
3343
3344
3345 // Release build checks
3346 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipsoidData) || (ellipsoidData == NULL), NULL);
3347
3348
3349
3350 // Debug build checks
3351 #if Q3_DEBUG
3352 if (0) // Further checks on ellipsoidData
3353 return(NULL);
3354 #endif
3355
3356
3357
3358 // Call the bottleneck
3359 E3System_Bottleneck();
3360
3361
3362
3363 // Call our implementation
3364 return(E3Ellipsoid_New(ellipsoidData));
3365 }
3366
3367
3368
3369
3370
3371 //=============================================================================
3372 // Q3Ellipsoid_Submit : Quesa API entry point.
3373 //-----------------------------------------------------------------------------
3374 TQ3Status
Q3Ellipsoid_Submit(const TQ3EllipsoidData * ellipsoidData,TQ3ViewObject view)3375 Q3Ellipsoid_Submit(const TQ3EllipsoidData *ellipsoidData, TQ3ViewObject view)
3376 {
3377
3378
3379 // Release build checks
3380 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipsoidData), kQ3Failure);
3381 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
3382
3383
3384
3385 // Debug build checks
3386 #if Q3_DEBUG
3387 if (0) // Further checks on ellipsoidData
3388 return(kQ3Failure);
3389
3390 if (0) // Further checks on view
3391 return(kQ3Failure);
3392 #endif
3393
3394
3395
3396 // Call the bottleneck
3397 E3System_Bottleneck();
3398
3399
3400
3401 // Call our implementation
3402 return(E3Ellipsoid_Submit(ellipsoidData, view));
3403 }
3404
3405
3406
3407
3408
3409 //=============================================================================
3410 // Q3Ellipsoid_SetData : Quesa API entry point.
3411 //-----------------------------------------------------------------------------
3412 TQ3Status
Q3Ellipsoid_SetData(TQ3GeometryObject ellipsoid,const TQ3EllipsoidData * ellipsoidData)3413 Q3Ellipsoid_SetData(TQ3GeometryObject ellipsoid, const TQ3EllipsoidData *ellipsoidData)
3414 {
3415
3416
3417 // Release build checks
3418 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3419 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipsoidData), kQ3Failure);
3420
3421
3422
3423 // Debug build checks
3424 #if Q3_DEBUG
3425 if (0) // Further checks on ellipsoid
3426 return(kQ3Failure);
3427
3428 if (0) // Further checks on ellipsoidData
3429 return(kQ3Failure);
3430 #endif
3431
3432
3433
3434 // Call the bottleneck
3435 E3System_Bottleneck();
3436
3437
3438
3439 // Call our implementation
3440 return(E3Ellipsoid_SetData(ellipsoid, ellipsoidData));
3441 }
3442
3443
3444
3445
3446
3447 //=============================================================================
3448 // Q3Ellipsoid_GetData : Quesa API entry point.
3449 //-----------------------------------------------------------------------------
3450 TQ3Status
Q3Ellipsoid_GetData(TQ3GeometryObject ellipsoid,TQ3EllipsoidData * ellipsoidData)3451 Q3Ellipsoid_GetData(TQ3GeometryObject ellipsoid, TQ3EllipsoidData *ellipsoidData)
3452 {
3453
3454
3455 // Release build checks
3456 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3457 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipsoidData), kQ3Failure);
3458
3459
3460
3461 // Debug build checks
3462 #if Q3_DEBUG
3463 if (0) // Further checks on ellipsoid
3464 return(kQ3Failure);
3465
3466 if (0) // Further checks on ellipsoidData
3467 return(kQ3Failure);
3468 #endif
3469
3470
3471
3472 // Call the bottleneck
3473 E3System_Bottleneck();
3474
3475
3476
3477 // Call our implementation
3478 return(E3Ellipsoid_GetData(ellipsoid, ellipsoidData));
3479 }
3480
3481
3482
3483
3484
3485 //=============================================================================
3486 // Q3Ellipsoid_SetOrigin : Quesa API entry point.
3487 //-----------------------------------------------------------------------------
3488 TQ3Status
Q3Ellipsoid_SetOrigin(TQ3GeometryObject ellipsoid,const TQ3Point3D * origin)3489 Q3Ellipsoid_SetOrigin(TQ3GeometryObject ellipsoid, const TQ3Point3D *origin)
3490 {
3491
3492
3493 // Release build checks
3494 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3495 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
3496
3497
3498
3499 // Debug build checks
3500 #if Q3_DEBUG
3501 if (0) // Further checks on ellipsoid
3502 return(kQ3Failure);
3503
3504 if (0) // Further checks on origin
3505 return(kQ3Failure);
3506 #endif
3507
3508
3509
3510 // Call the bottleneck
3511 E3System_Bottleneck();
3512
3513
3514
3515 // Call our implementation
3516 return(E3Ellipsoid_SetOrigin(ellipsoid, origin));
3517 }
3518
3519
3520
3521
3522
3523 //=============================================================================
3524 // Q3Ellipsoid_SetOrientation : Quesa API entry point.
3525 //-----------------------------------------------------------------------------
3526 TQ3Status
Q3Ellipsoid_SetOrientation(TQ3GeometryObject ellipsoid,const TQ3Vector3D * orientation)3527 Q3Ellipsoid_SetOrientation(TQ3GeometryObject ellipsoid, const TQ3Vector3D *orientation)
3528 {
3529
3530
3531 // Release build checks
3532 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3533 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
3534
3535
3536
3537 // Debug build checks
3538 #if Q3_DEBUG
3539 if (0) // Further checks on ellipsoid
3540 return(kQ3Failure);
3541
3542 if (0) // Further checks on orientation
3543 return(kQ3Failure);
3544 #endif
3545
3546
3547
3548 // Call the bottleneck
3549 E3System_Bottleneck();
3550
3551
3552
3553 // Call our implementation
3554 return(E3Ellipsoid_SetOrientation(ellipsoid, orientation));
3555 }
3556
3557
3558
3559
3560
3561 //=============================================================================
3562 // Q3Ellipsoid_SetMajorRadius : Quesa API entry point.
3563 //-----------------------------------------------------------------------------
3564 TQ3Status
Q3Ellipsoid_SetMajorRadius(TQ3GeometryObject ellipsoid,const TQ3Vector3D * majorRadius)3565 Q3Ellipsoid_SetMajorRadius(TQ3GeometryObject ellipsoid, const TQ3Vector3D *majorRadius)
3566 {
3567
3568
3569 // Release build checks
3570 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3571 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
3572
3573
3574
3575 // Debug build checks
3576 #if Q3_DEBUG
3577 if (0) // Further checks on ellipsoid
3578 return(kQ3Failure);
3579
3580 if (0) // Further checks on majorRadius
3581 return(kQ3Failure);
3582 #endif
3583
3584
3585
3586 // Call the bottleneck
3587 E3System_Bottleneck();
3588
3589
3590
3591 // Call our implementation
3592 return(E3Ellipsoid_SetMajorRadius(ellipsoid, majorRadius));
3593 }
3594
3595
3596
3597
3598
3599 //=============================================================================
3600 // Q3Ellipsoid_SetMinorRadius : Quesa API entry point.
3601 //-----------------------------------------------------------------------------
3602 TQ3Status
Q3Ellipsoid_SetMinorRadius(TQ3GeometryObject ellipsoid,const TQ3Vector3D * minorRadius)3603 Q3Ellipsoid_SetMinorRadius(TQ3GeometryObject ellipsoid, const TQ3Vector3D *minorRadius)
3604 {
3605
3606
3607 // Release build checks
3608 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3609 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
3610
3611
3612
3613 // Debug build checks
3614 #if Q3_DEBUG
3615 if (0) // Further checks on ellipsoid
3616 return(kQ3Failure);
3617
3618 if (0) // Further checks on minorRadius
3619 return(kQ3Failure);
3620 #endif
3621
3622
3623
3624 // Call the bottleneck
3625 E3System_Bottleneck();
3626
3627
3628
3629 // Call our implementation
3630 return(E3Ellipsoid_SetMinorRadius(ellipsoid, minorRadius));
3631 }
3632
3633
3634
3635
3636
3637 //=============================================================================
3638 // Q3Ellipsoid_GetOrigin : Quesa API entry point.
3639 //-----------------------------------------------------------------------------
3640 TQ3Status
Q3Ellipsoid_GetOrigin(TQ3GeometryObject ellipsoid,TQ3Point3D * origin)3641 Q3Ellipsoid_GetOrigin(TQ3GeometryObject ellipsoid, TQ3Point3D *origin)
3642 {
3643
3644
3645 // Release build checks
3646 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3647 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
3648
3649
3650
3651 // Debug build checks
3652 #if Q3_DEBUG
3653 if (0) // Further checks on ellipsoid
3654 return(kQ3Failure);
3655
3656 if (0) // Further checks on origin
3657 return(kQ3Failure);
3658 #endif
3659
3660
3661
3662 // Call the bottleneck
3663 E3System_Bottleneck();
3664
3665
3666
3667 // Call our implementation
3668 return(E3Ellipsoid_GetOrigin(ellipsoid, origin));
3669 }
3670
3671
3672
3673
3674
3675 //=============================================================================
3676 // Q3Ellipsoid_GetOrientation : Quesa API entry point.
3677 //-----------------------------------------------------------------------------
3678 TQ3Status
Q3Ellipsoid_GetOrientation(TQ3GeometryObject ellipsoid,TQ3Vector3D * orientation)3679 Q3Ellipsoid_GetOrientation(TQ3GeometryObject ellipsoid, TQ3Vector3D *orientation)
3680 {
3681
3682
3683 // Release build checks
3684 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3685 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
3686
3687
3688
3689 // Debug build checks
3690 #if Q3_DEBUG
3691 if (0) // Further checks on ellipsoid
3692 return(kQ3Failure);
3693
3694 if (0) // Further checks on orientation
3695 return(kQ3Failure);
3696 #endif
3697
3698
3699
3700 // Call the bottleneck
3701 E3System_Bottleneck();
3702
3703
3704
3705 // Call our implementation
3706 return(E3Ellipsoid_GetOrientation(ellipsoid, orientation));
3707 }
3708
3709
3710
3711
3712
3713 //=============================================================================
3714 // Q3Ellipsoid_GetMajorRadius : Quesa API entry point.
3715 //-----------------------------------------------------------------------------
3716 TQ3Status
Q3Ellipsoid_GetMajorRadius(TQ3GeometryObject ellipsoid,TQ3Vector3D * majorRadius)3717 Q3Ellipsoid_GetMajorRadius(TQ3GeometryObject ellipsoid, TQ3Vector3D *majorRadius)
3718 {
3719
3720
3721 // Release build checks
3722 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3723 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
3724
3725
3726
3727 // Debug build checks
3728 #if Q3_DEBUG
3729 if (0) // Further checks on ellipsoid
3730 return(kQ3Failure);
3731
3732 if (0) // Further checks on majorRadius
3733 return(kQ3Failure);
3734 #endif
3735
3736
3737
3738 // Call the bottleneck
3739 E3System_Bottleneck();
3740
3741
3742
3743 // Call our implementation
3744 return(E3Ellipsoid_GetMajorRadius(ellipsoid, majorRadius));
3745 }
3746
3747
3748
3749
3750
3751 //=============================================================================
3752 // Q3Ellipsoid_GetMinorRadius : Quesa API entry point.
3753 //-----------------------------------------------------------------------------
3754 TQ3Status
Q3Ellipsoid_GetMinorRadius(TQ3GeometryObject ellipsoid,TQ3Vector3D * minorRadius)3755 Q3Ellipsoid_GetMinorRadius(TQ3GeometryObject ellipsoid, TQ3Vector3D *minorRadius)
3756 {
3757
3758
3759 // Release build checks
3760 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( ellipsoid ), kQ3Failure);
3761 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
3762
3763
3764
3765 // Debug build checks
3766 #if Q3_DEBUG
3767 if (0) // Further checks on ellipsoid
3768 return(kQ3Failure);
3769
3770 if (0) // Further checks on minorRadius
3771 return(kQ3Failure);
3772 #endif
3773
3774
3775
3776 // Call the bottleneck
3777 E3System_Bottleneck();
3778
3779
3780
3781 // Call our implementation
3782 return(E3Ellipsoid_GetMinorRadius(ellipsoid, minorRadius));
3783 }
3784
3785
3786
3787
3788
3789 //=============================================================================
3790 // Q3Ellipsoid_EmptyData : Quesa API entry point.
3791 //-----------------------------------------------------------------------------
3792 TQ3Status
Q3Ellipsoid_EmptyData(TQ3EllipsoidData * ellipsoidData)3793 Q3Ellipsoid_EmptyData(TQ3EllipsoidData *ellipsoidData)
3794 {
3795
3796
3797 // Release build checks
3798 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ellipsoidData), kQ3Failure);
3799
3800
3801
3802 // Debug build checks
3803 #if Q3_DEBUG
3804 if (0) // Further checks on ellipsoidData
3805 return(kQ3Failure);
3806 #endif
3807
3808
3809
3810 // Call the bottleneck
3811 E3System_Bottleneck();
3812
3813
3814
3815 // Call our implementation
3816 return(E3Ellipsoid_EmptyData(ellipsoidData));
3817 }
3818
3819
3820
3821
3822
3823 //=============================================================================
3824 // Q3GeneralPolygon_New : Quesa API entry point.
3825 //-----------------------------------------------------------------------------
3826 TQ3GeometryObject
Q3GeneralPolygon_New(const TQ3GeneralPolygonData * generalPolygonData)3827 Q3GeneralPolygon_New(const TQ3GeneralPolygonData *generalPolygonData)
3828 {
3829
3830
3831 // Release build checks
3832 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(generalPolygonData), NULL);
3833
3834
3835
3836 // Debug build checks
3837 #if Q3_DEBUG
3838 if (0) // Further checks on generalPolygonData
3839 return(NULL);
3840 #endif
3841
3842
3843
3844 // Call the bottleneck
3845 E3System_Bottleneck();
3846
3847
3848
3849 // Call our implementation
3850 return(E3GeneralPolygon_New(generalPolygonData));
3851 }
3852
3853
3854
3855
3856
3857 //=============================================================================
3858 // Q3GeneralPolygon_Submit : Quesa API entry point.
3859 //-----------------------------------------------------------------------------
3860 TQ3Status
Q3GeneralPolygon_Submit(const TQ3GeneralPolygonData * generalPolygonData,TQ3ViewObject view)3861 Q3GeneralPolygon_Submit(const TQ3GeneralPolygonData *generalPolygonData, TQ3ViewObject view)
3862 {
3863
3864
3865 // Release build checks
3866 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(generalPolygonData), kQ3Failure);
3867 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
3868
3869
3870
3871 // Debug build checks
3872 #if Q3_DEBUG
3873 if (0) // Further checks on generalPolygonData
3874 return(kQ3Failure);
3875
3876 if (0) // Further checks on view
3877 return(kQ3Failure);
3878 #endif
3879
3880
3881
3882 // Call the bottleneck
3883 E3System_Bottleneck();
3884
3885
3886
3887 // Call our implementation
3888 return(E3GeneralPolygon_Submit(generalPolygonData, view));
3889 }
3890
3891
3892
3893
3894
3895 //=============================================================================
3896 // Q3GeneralPolygon_SetData : Quesa API entry point.
3897 //-----------------------------------------------------------------------------
3898 TQ3Status
Q3GeneralPolygon_SetData(TQ3GeometryObject generalPolygon,const TQ3GeneralPolygonData * generalPolygonData)3899 Q3GeneralPolygon_SetData(TQ3GeometryObject generalPolygon, const TQ3GeneralPolygonData *generalPolygonData)
3900 {
3901
3902
3903 // Release build checks
3904 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
3905 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(generalPolygonData), kQ3Failure);
3906
3907
3908
3909 // Debug build checks
3910 #if Q3_DEBUG
3911 if (0) // Further checks on generalPolygon
3912 return(kQ3Failure);
3913
3914 if (0) // Further checks on generalPolygonData
3915 return(kQ3Failure);
3916 #endif
3917
3918
3919
3920 // Call the bottleneck
3921 E3System_Bottleneck();
3922
3923
3924
3925 // Call our implementation
3926 return(E3GeneralPolygon_SetData(generalPolygon, generalPolygonData));
3927 }
3928
3929
3930
3931
3932
3933 //=============================================================================
3934 // Q3GeneralPolygon_GetData : Quesa API entry point.
3935 //-----------------------------------------------------------------------------
3936 TQ3Status
Q3GeneralPolygon_GetData(TQ3GeometryObject polygon,TQ3GeneralPolygonData * generalPolygonData)3937 Q3GeneralPolygon_GetData(TQ3GeometryObject polygon, TQ3GeneralPolygonData *generalPolygonData)
3938 {
3939
3940
3941 // Release build checks
3942 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
3943 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(generalPolygonData), kQ3Failure);
3944
3945
3946
3947 // Debug build checks
3948 #if Q3_DEBUG
3949 if (0) // Further checks on polygon
3950 return(kQ3Failure);
3951
3952 if (0) // Further checks on generalPolygonData
3953 return(kQ3Failure);
3954 #endif
3955
3956
3957
3958 // Call the bottleneck
3959 E3System_Bottleneck();
3960
3961
3962
3963 // Call our implementation
3964 return(E3GeneralPolygon_GetData(polygon, generalPolygonData));
3965 }
3966
3967
3968
3969
3970
3971 //=============================================================================
3972 // Q3GeneralPolygon_EmptyData : Quesa API entry point.
3973 //-----------------------------------------------------------------------------
3974 TQ3Status
Q3GeneralPolygon_EmptyData(TQ3GeneralPolygonData * generalPolygonData)3975 Q3GeneralPolygon_EmptyData(TQ3GeneralPolygonData *generalPolygonData)
3976 {
3977
3978
3979 // Release build checks
3980 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(generalPolygonData), kQ3Failure);
3981
3982
3983
3984 // Debug build checks
3985 #if Q3_DEBUG
3986 if (0) // Further checks on generalPolygonData
3987 return(kQ3Failure);
3988 #endif
3989
3990
3991
3992 // Call the bottleneck
3993 E3System_Bottleneck();
3994
3995
3996
3997 // Call our implementation
3998 return(E3GeneralPolygon_EmptyData(generalPolygonData));
3999 }
4000
4001
4002
4003
4004
4005 //=============================================================================
4006 // Q3GeneralPolygon_GetVertexPosition : Quesa API entry point.
4007 //-----------------------------------------------------------------------------
4008 TQ3Status
Q3GeneralPolygon_GetVertexPosition(TQ3GeometryObject generalPolygon,TQ3Uns32 contourIndex,TQ3Uns32 pointIndex,TQ3Point3D * position)4009 Q3GeneralPolygon_GetVertexPosition(TQ3GeometryObject generalPolygon, TQ3Uns32 contourIndex, TQ3Uns32 pointIndex, TQ3Point3D *position)
4010 {
4011
4012
4013 // Release build checks
4014 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
4015 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
4016
4017
4018
4019 // Debug build checks
4020 #if Q3_DEBUG
4021 if (0) // Further checks on generalPolygon
4022 return(kQ3Failure);
4023
4024 if (0) // Further checks on contourIndex
4025 return(kQ3Failure);
4026
4027 if (0) // Further checks on pointIndex
4028 return(kQ3Failure);
4029
4030 if (0) // Further checks on position
4031 return(kQ3Failure);
4032 #endif
4033
4034
4035
4036 // Call the bottleneck
4037 E3System_Bottleneck();
4038
4039
4040
4041 // Call our implementation
4042 return(E3GeneralPolygon_GetVertexPosition(generalPolygon, contourIndex, pointIndex, position));
4043 }
4044
4045
4046
4047
4048
4049 //=============================================================================
4050 // Q3GeneralPolygon_SetVertexPosition : Quesa API entry point.
4051 //-----------------------------------------------------------------------------
4052 TQ3Status
Q3GeneralPolygon_SetVertexPosition(TQ3GeometryObject generalPolygon,TQ3Uns32 contourIndex,TQ3Uns32 pointIndex,const TQ3Point3D * position)4053 Q3GeneralPolygon_SetVertexPosition(TQ3GeometryObject generalPolygon, TQ3Uns32 contourIndex, TQ3Uns32 pointIndex, const TQ3Point3D *position)
4054 {
4055
4056
4057 // Release build checks
4058 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
4059 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
4060
4061
4062
4063 // Debug build checks
4064 #if Q3_DEBUG
4065 if (0) // Further checks on generalPolygon
4066 return(kQ3Failure);
4067
4068 if (0) // Further checks on contourIndex
4069 return(kQ3Failure);
4070
4071 if (0) // Further checks on pointIndex
4072 return(kQ3Failure);
4073
4074 if (0) // Further checks on position
4075 return(kQ3Failure);
4076 #endif
4077
4078
4079
4080 // Call the bottleneck
4081 E3System_Bottleneck();
4082
4083
4084
4085 // Call our implementation
4086 return(E3GeneralPolygon_SetVertexPosition(generalPolygon, contourIndex, pointIndex, position));
4087 }
4088
4089
4090
4091
4092
4093 //=============================================================================
4094 // Q3GeneralPolygon_GetVertexAttributeSet : Quesa API entry point.
4095 //-----------------------------------------------------------------------------
4096 TQ3Status
Q3GeneralPolygon_GetVertexAttributeSet(TQ3GeometryObject generalPolygon,TQ3Uns32 contourIndex,TQ3Uns32 pointIndex,TQ3AttributeSet * attributeSet)4097 Q3GeneralPolygon_GetVertexAttributeSet(TQ3GeometryObject generalPolygon, TQ3Uns32 contourIndex, TQ3Uns32 pointIndex, TQ3AttributeSet *attributeSet)
4098 {
4099
4100
4101 // Release build checks
4102 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
4103 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
4104
4105
4106
4107 // Debug build checks
4108 #if Q3_DEBUG
4109 if (0) // Further checks on generalPolygon
4110 return(kQ3Failure);
4111
4112 if (0) // Further checks on contourIndex
4113 return(kQ3Failure);
4114
4115 if (0) // Further checks on pointIndex
4116 return(kQ3Failure);
4117
4118 if (0) // Further checks on attributeSet
4119 return(kQ3Failure);
4120 #endif
4121
4122
4123
4124 // Call the bottleneck
4125 E3System_Bottleneck();
4126
4127
4128
4129 // Call our implementation
4130 return(E3GeneralPolygon_GetVertexAttributeSet(generalPolygon, contourIndex, pointIndex, attributeSet));
4131 }
4132
4133
4134
4135
4136
4137 //=============================================================================
4138 // Q3GeneralPolygon_SetVertexAttributeSet : Quesa API entry point.
4139 //-----------------------------------------------------------------------------
4140 TQ3Status
Q3GeneralPolygon_SetVertexAttributeSet(TQ3GeometryObject generalPolygon,TQ3Uns32 contourIndex,TQ3Uns32 pointIndex,TQ3AttributeSet attributeSet)4141 Q3GeneralPolygon_SetVertexAttributeSet(TQ3GeometryObject generalPolygon, TQ3Uns32 contourIndex, TQ3Uns32 pointIndex, TQ3AttributeSet attributeSet)
4142 {
4143
4144
4145 // Release build checks
4146 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
4147
4148
4149
4150 // Debug build checks
4151 #if Q3_DEBUG
4152 if (0) // Further checks on generalPolygon
4153 return(kQ3Failure);
4154
4155 if (0) // Further checks on contourIndex
4156 return(kQ3Failure);
4157
4158 if (0) // Further checks on pointIndex
4159 return(kQ3Failure);
4160
4161 if (0) // Further checks on attributeSet
4162 return(kQ3Failure);
4163 #endif
4164
4165
4166
4167 // Call the bottleneck
4168 E3System_Bottleneck();
4169
4170
4171
4172 // Call our implementation
4173 return(E3GeneralPolygon_SetVertexAttributeSet(generalPolygon, contourIndex, pointIndex, attributeSet));
4174 }
4175
4176
4177
4178
4179
4180 //=============================================================================
4181 // Q3GeneralPolygon_SetShapeHint : Quesa API entry point.
4182 //-----------------------------------------------------------------------------
4183 TQ3Status
Q3GeneralPolygon_SetShapeHint(TQ3GeometryObject generalPolygon,TQ3GeneralPolygonShapeHint shapeHint)4184 Q3GeneralPolygon_SetShapeHint(TQ3GeometryObject generalPolygon, TQ3GeneralPolygonShapeHint shapeHint)
4185 {
4186
4187
4188 // Release build checks
4189 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
4190
4191
4192
4193 // Debug build checks
4194 #if Q3_DEBUG
4195 if (0) // Further checks on generalPolygon
4196 return(kQ3Failure);
4197
4198 if (0) // Further checks on shapeHint
4199 return(kQ3Failure);
4200 #endif
4201
4202
4203
4204 // Call the bottleneck
4205 E3System_Bottleneck();
4206
4207
4208
4209 // Call our implementation
4210 return(E3GeneralPolygon_SetShapeHint(generalPolygon, shapeHint));
4211 }
4212
4213
4214
4215
4216
4217 //=============================================================================
4218 // Q3GeneralPolygon_GetShapeHint : Quesa API entry point.
4219 //-----------------------------------------------------------------------------
4220 TQ3Status
Q3GeneralPolygon_GetShapeHint(TQ3GeometryObject generalPolygon,TQ3GeneralPolygonShapeHint * shapeHint)4221 Q3GeneralPolygon_GetShapeHint(TQ3GeometryObject generalPolygon, TQ3GeneralPolygonShapeHint *shapeHint)
4222 {
4223
4224
4225 // Release build checks
4226 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( generalPolygon ), kQ3Failure);
4227 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(shapeHint), kQ3Failure);
4228
4229
4230
4231 // Debug build checks
4232 #if Q3_DEBUG
4233 if (0) // Further checks on generalPolygon
4234 return(kQ3Failure);
4235
4236 if (0) // Further checks on shapeHint
4237 return(kQ3Failure);
4238 #endif
4239
4240
4241
4242 // Call the bottleneck
4243 E3System_Bottleneck();
4244
4245
4246
4247 // Call our implementation
4248 return(E3GeneralPolygon_GetShapeHint(generalPolygon, shapeHint));
4249 }
4250
4251
4252
4253
4254
4255 //=============================================================================
4256 // Q3Line_New : Quesa API entry point.
4257 //-----------------------------------------------------------------------------
4258 TQ3GeometryObject
Q3Line_New(const TQ3LineData * lineData)4259 Q3Line_New(const TQ3LineData *lineData)
4260 {
4261
4262
4263 // Release build checks
4264 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(lineData), NULL);
4265
4266
4267
4268 // Debug build checks
4269 #if Q3_DEBUG
4270 if (0) // Further checks on lineData
4271 return(NULL);
4272 #endif
4273
4274
4275
4276 // Call the bottleneck
4277 E3System_Bottleneck();
4278
4279
4280
4281 // Call our implementation
4282 return(E3Line_New(lineData));
4283 }
4284
4285
4286
4287
4288
4289 //=============================================================================
4290 // Q3Line_Submit : Quesa API entry point.
4291 //-----------------------------------------------------------------------------
4292 TQ3Status
Q3Line_Submit(const TQ3LineData * lineData,TQ3ViewObject view)4293 Q3Line_Submit(const TQ3LineData *lineData, TQ3ViewObject view)
4294 {
4295
4296
4297 // Release build checks
4298 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(lineData), kQ3Failure);
4299 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
4300
4301
4302
4303 // Debug build checks
4304 #if Q3_DEBUG
4305 if (0) // Further checks on lineData
4306 return(kQ3Failure);
4307
4308 if (0) // Further checks on view
4309 return(kQ3Failure);
4310 #endif
4311
4312
4313
4314 // Call the bottleneck
4315 E3System_Bottleneck();
4316
4317
4318
4319 // Call our implementation
4320 return(E3Line_Submit(lineData, view));
4321 }
4322
4323
4324
4325
4326
4327 //=============================================================================
4328 // Q3Line_GetData : Quesa API entry point.
4329 //-----------------------------------------------------------------------------
4330 TQ3Status
Q3Line_GetData(TQ3GeometryObject line,TQ3LineData * lineData)4331 Q3Line_GetData(TQ3GeometryObject line, TQ3LineData *lineData)
4332 {
4333
4334
4335 // Release build checks
4336 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( line ), kQ3Failure);
4337 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(lineData), kQ3Failure);
4338
4339
4340
4341 // Debug build checks
4342 #if Q3_DEBUG
4343 if (0) // Further checks on line
4344 return(kQ3Failure);
4345
4346 if (0) // Further checks on lineData
4347 return(kQ3Failure);
4348 #endif
4349
4350
4351
4352 // Call the bottleneck
4353 E3System_Bottleneck();
4354
4355
4356
4357 // Call our implementation
4358 return(E3Line_GetData(line, lineData));
4359 }
4360
4361
4362
4363
4364
4365 //=============================================================================
4366 // Q3Line_SetData : Quesa API entry point.
4367 //-----------------------------------------------------------------------------
4368 TQ3Status
Q3Line_SetData(TQ3GeometryObject line,const TQ3LineData * lineData)4369 Q3Line_SetData(TQ3GeometryObject line, const TQ3LineData *lineData)
4370 {
4371
4372
4373 // Release build checks
4374 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( line ), kQ3Failure);
4375 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(lineData), kQ3Failure);
4376
4377
4378
4379 // Debug build checks
4380 #if Q3_DEBUG
4381 if (0) // Further checks on line
4382 return(kQ3Failure);
4383
4384 if (0) // Further checks on lineData
4385 return(kQ3Failure);
4386 #endif
4387
4388
4389
4390 // Call the bottleneck
4391 E3System_Bottleneck();
4392
4393
4394
4395 // Call our implementation
4396 return(E3Line_SetData(line, lineData));
4397 }
4398
4399
4400
4401
4402
4403 //=============================================================================
4404 // Q3Line_GetVertexPosition : Quesa API entry point.
4405 //-----------------------------------------------------------------------------
4406 TQ3Status
Q3Line_GetVertexPosition(TQ3GeometryObject line,TQ3Uns32 index,TQ3Point3D * position)4407 Q3Line_GetVertexPosition(TQ3GeometryObject line, TQ3Uns32 index, TQ3Point3D *position)
4408 {
4409
4410
4411 // Release build checks
4412 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( line ), kQ3Failure);
4413 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
4414
4415
4416
4417 // Debug build checks
4418 #if Q3_DEBUG
4419 if (0) // Further checks on line
4420 return(kQ3Failure);
4421
4422 if (0) // Further checks on index
4423 return(kQ3Failure);
4424
4425 if (0) // Further checks on position
4426 return(kQ3Failure);
4427 #endif
4428
4429
4430
4431 // Call the bottleneck
4432 E3System_Bottleneck();
4433
4434
4435
4436 // Call our implementation
4437 return(E3Line_GetVertexPosition(line, index, position));
4438 }
4439
4440
4441
4442
4443
4444 //=============================================================================
4445 // Q3Line_SetVertexPosition : Quesa API entry point.
4446 //-----------------------------------------------------------------------------
4447 TQ3Status
Q3Line_SetVertexPosition(TQ3GeometryObject line,TQ3Uns32 index,const TQ3Point3D * position)4448 Q3Line_SetVertexPosition(TQ3GeometryObject line, TQ3Uns32 index, const TQ3Point3D *position)
4449 {
4450
4451
4452 // Release build checks
4453 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( line ), kQ3Failure);
4454 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
4455
4456
4457
4458 // Debug build checks
4459 #if Q3_DEBUG
4460 if (0) // Further checks on line
4461 return(kQ3Failure);
4462
4463 if (0) // Further checks on index
4464 return(kQ3Failure);
4465
4466 if (0) // Further checks on position
4467 return(kQ3Failure);
4468 #endif
4469
4470
4471
4472 // Call the bottleneck
4473 E3System_Bottleneck();
4474
4475
4476
4477 // Call our implementation
4478 return(E3Line_SetVertexPosition(line, index, position));
4479 }
4480
4481
4482
4483
4484
4485 //=============================================================================
4486 // Q3Line_GetVertexAttributeSet : Quesa API entry point.
4487 //-----------------------------------------------------------------------------
4488 TQ3Status
Q3Line_GetVertexAttributeSet(TQ3GeometryObject line,TQ3Uns32 index,TQ3AttributeSet * attributeSet)4489 Q3Line_GetVertexAttributeSet(TQ3GeometryObject line, TQ3Uns32 index, TQ3AttributeSet *attributeSet)
4490 {
4491
4492
4493 // Release build checks
4494 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( line ), kQ3Failure);
4495 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
4496
4497
4498
4499 // Debug build checks
4500 #if Q3_DEBUG
4501 if (0) // Further checks on line
4502 return(kQ3Failure);
4503
4504 if (0) // Further checks on index
4505 return(kQ3Failure);
4506
4507 if (0) // Further checks on attributeSet
4508 return(kQ3Failure);
4509 #endif
4510
4511
4512
4513 // Call the bottleneck
4514 E3System_Bottleneck();
4515
4516
4517
4518 // Call our implementation
4519 return(E3Line_GetVertexAttributeSet(line, index, attributeSet));
4520 }
4521
4522
4523
4524
4525
4526 //=============================================================================
4527 // Q3Line_SetVertexAttributeSet : Quesa API entry point.
4528 //-----------------------------------------------------------------------------
4529 TQ3Status
Q3Line_SetVertexAttributeSet(TQ3GeometryObject line,TQ3Uns32 index,TQ3AttributeSet attributeSet)4530 Q3Line_SetVertexAttributeSet(TQ3GeometryObject line, TQ3Uns32 index, TQ3AttributeSet attributeSet)
4531 {
4532
4533
4534 // Release build checks
4535 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( line ), kQ3Failure);
4536
4537
4538
4539 // Debug build checks
4540 #if Q3_DEBUG
4541 if (0) // Further checks on line
4542 return(kQ3Failure);
4543
4544 if (0) // Further checks on index
4545 return(kQ3Failure);
4546
4547 if (0) // Further checks on attributeSet
4548 return(kQ3Failure);
4549 #endif
4550
4551
4552
4553 // Call the bottleneck
4554 E3System_Bottleneck();
4555
4556
4557
4558 // Call our implementation
4559 return(E3Line_SetVertexAttributeSet(line, index, attributeSet));
4560 }
4561
4562
4563
4564
4565
4566 //=============================================================================
4567 // Q3Line_EmptyData : Quesa API entry point.
4568 //-----------------------------------------------------------------------------
4569 TQ3Status
Q3Line_EmptyData(TQ3LineData * lineData)4570 Q3Line_EmptyData(TQ3LineData *lineData)
4571 {
4572
4573
4574 // Release build checks
4575 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(lineData), kQ3Failure);
4576
4577
4578
4579 // Debug build checks
4580 #if Q3_DEBUG
4581 if (0) // Further checks on lineData
4582 return(kQ3Failure);
4583 #endif
4584
4585
4586
4587 // Call the bottleneck
4588 E3System_Bottleneck();
4589
4590
4591
4592 // Call our implementation
4593 return(E3Line_EmptyData(lineData));
4594 }
4595
4596
4597
4598
4599
4600 //=============================================================================
4601 // Q3Marker_New : Quesa API entry point.
4602 //-----------------------------------------------------------------------------
4603 TQ3GeometryObject
Q3Marker_New(const TQ3MarkerData * markerData)4604 Q3Marker_New(const TQ3MarkerData *markerData)
4605 {
4606
4607
4608 // Release build checks
4609 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(markerData), NULL);
4610
4611
4612
4613 // Debug build checks
4614 #if Q3_DEBUG
4615 if (0) // Further checks on markerData
4616 return(NULL);
4617 #endif
4618
4619
4620
4621 // Call the bottleneck
4622 E3System_Bottleneck();
4623
4624
4625
4626 // Call our implementation
4627 return(E3Marker_New(markerData));
4628 }
4629
4630
4631
4632
4633
4634 //=============================================================================
4635 // Q3Marker_Submit : Quesa API entry point.
4636 //-----------------------------------------------------------------------------
4637 TQ3Status
Q3Marker_Submit(const TQ3MarkerData * markerData,TQ3ViewObject view)4638 Q3Marker_Submit(const TQ3MarkerData *markerData, TQ3ViewObject view)
4639 {
4640
4641
4642 // Release build checks
4643 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(markerData), kQ3Failure);
4644 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
4645
4646
4647
4648 // Debug build checks
4649 #if Q3_DEBUG
4650 if (0) // Further checks on markerData
4651 return(kQ3Failure);
4652
4653 if (0) // Further checks on view
4654 return(kQ3Failure);
4655 #endif
4656
4657
4658
4659 // Call the bottleneck
4660 E3System_Bottleneck();
4661
4662
4663
4664 // Call our implementation
4665 return(E3Marker_Submit(markerData, view));
4666 }
4667
4668
4669
4670
4671
4672 //=============================================================================
4673 // Q3Marker_SetData : Quesa API entry point.
4674 //-----------------------------------------------------------------------------
4675 TQ3Status
Q3Marker_SetData(TQ3GeometryObject geometry,const TQ3MarkerData * markerData)4676 Q3Marker_SetData(TQ3GeometryObject geometry, const TQ3MarkerData *markerData)
4677 {
4678
4679
4680 // Release build checks
4681 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
4682 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(markerData), kQ3Failure);
4683
4684
4685
4686 // Debug build checks
4687 #if Q3_DEBUG
4688 if (0) // Further checks on geometry
4689 return(kQ3Failure);
4690
4691 if (0) // Further checks on markerData
4692 return(kQ3Failure);
4693 #endif
4694
4695
4696
4697 // Call the bottleneck
4698 E3System_Bottleneck();
4699
4700
4701
4702 // Call our implementation
4703 return(E3Marker_SetData(geometry, markerData));
4704 }
4705
4706
4707
4708
4709
4710 //=============================================================================
4711 // Q3Marker_GetData : Quesa API entry point.
4712 //-----------------------------------------------------------------------------
4713 TQ3Status
Q3Marker_GetData(TQ3GeometryObject geometry,TQ3MarkerData * markerData)4714 Q3Marker_GetData(TQ3GeometryObject geometry, TQ3MarkerData *markerData)
4715 {
4716
4717
4718 // Release build checks
4719 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
4720 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(markerData), kQ3Failure);
4721
4722
4723
4724 // Debug build checks
4725 #if Q3_DEBUG
4726 if (0) // Further checks on geometry
4727 return(kQ3Failure);
4728
4729 if (0) // Further checks on markerData
4730 return(kQ3Failure);
4731 #endif
4732
4733
4734
4735 // Call the bottleneck
4736 E3System_Bottleneck();
4737
4738
4739
4740 // Call our implementation
4741 return(E3Marker_GetData(geometry, markerData));
4742 }
4743
4744
4745
4746
4747
4748 //=============================================================================
4749 // Q3Marker_EmptyData : Quesa API entry point.
4750 //-----------------------------------------------------------------------------
4751 TQ3Status
Q3Marker_EmptyData(TQ3MarkerData * markerData)4752 Q3Marker_EmptyData(TQ3MarkerData *markerData)
4753 {
4754
4755
4756 // Release build checks
4757 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(markerData), kQ3Failure);
4758
4759
4760
4761 // Debug build checks
4762 #if Q3_DEBUG
4763 if (0) // Further checks on markerData
4764 return(kQ3Failure);
4765 #endif
4766
4767
4768
4769 // Call the bottleneck
4770 E3System_Bottleneck();
4771
4772
4773
4774 // Call our implementation
4775 return(E3Marker_EmptyData(markerData));
4776 }
4777
4778
4779
4780
4781
4782 //=============================================================================
4783 // Q3Marker_GetPosition : Quesa API entry point.
4784 //-----------------------------------------------------------------------------
4785 TQ3Status
Q3Marker_GetPosition(TQ3GeometryObject marker,TQ3Point3D * location)4786 Q3Marker_GetPosition(TQ3GeometryObject marker, TQ3Point3D *location)
4787 {
4788
4789
4790 // Release build checks
4791 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
4792 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(location), kQ3Failure);
4793
4794
4795
4796 // Debug build checks
4797 #if Q3_DEBUG
4798 if (0) // Further checks on marker
4799 return(kQ3Failure);
4800
4801 if (0) // Further checks on location
4802 return(kQ3Failure);
4803 #endif
4804
4805
4806
4807 // Call the bottleneck
4808 E3System_Bottleneck();
4809
4810
4811
4812 // Call our implementation
4813 return(E3Marker_GetPosition(marker, location));
4814 }
4815
4816
4817
4818
4819
4820 //=============================================================================
4821 // Q3Marker_SetPosition : Quesa API entry point.
4822 //-----------------------------------------------------------------------------
4823 TQ3Status
Q3Marker_SetPosition(TQ3GeometryObject marker,const TQ3Point3D * location)4824 Q3Marker_SetPosition(TQ3GeometryObject marker, const TQ3Point3D *location)
4825 {
4826
4827
4828 // Release build checks
4829 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
4830 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(location), kQ3Failure);
4831
4832
4833
4834 // Debug build checks
4835 #if Q3_DEBUG
4836 if (0) // Further checks on marker
4837 return(kQ3Failure);
4838
4839 if (0) // Further checks on location
4840 return(kQ3Failure);
4841 #endif
4842
4843
4844
4845 // Call the bottleneck
4846 E3System_Bottleneck();
4847
4848
4849
4850 // Call our implementation
4851 return(E3Marker_SetPosition(marker, location));
4852 }
4853
4854
4855
4856
4857
4858 //=============================================================================
4859 // Q3Marker_GetXOffset : Quesa API entry point.
4860 //-----------------------------------------------------------------------------
4861 TQ3Status
Q3Marker_GetXOffset(TQ3GeometryObject marker,TQ3Int32 * xOffset)4862 Q3Marker_GetXOffset(TQ3GeometryObject marker, TQ3Int32 *xOffset)
4863 {
4864
4865
4866 // Release build checks
4867 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
4868 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(xOffset), kQ3Failure);
4869
4870
4871
4872 // Debug build checks
4873 #if Q3_DEBUG
4874 if (0) // Further checks on marker
4875 return(kQ3Failure);
4876
4877 if (0) // Further checks on xOffset
4878 return(kQ3Failure);
4879 #endif
4880
4881
4882
4883 // Call the bottleneck
4884 E3System_Bottleneck();
4885
4886
4887
4888 // Call our implementation
4889 return(E3Marker_GetXOffset(marker, xOffset));
4890 }
4891
4892
4893
4894
4895
4896 //=============================================================================
4897 // Q3Marker_SetXOffset : Quesa API entry point.
4898 //-----------------------------------------------------------------------------
4899 TQ3Status
Q3Marker_SetXOffset(TQ3GeometryObject marker,TQ3Int32 xOffset)4900 Q3Marker_SetXOffset(TQ3GeometryObject marker, TQ3Int32 xOffset)
4901 {
4902
4903
4904 // Release build checks
4905 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
4906
4907
4908
4909 // Debug build checks
4910 #if Q3_DEBUG
4911 if (0) // Further checks on marker
4912 return(kQ3Failure);
4913
4914 if (0) // Further checks on xOffset
4915 return(kQ3Failure);
4916 #endif
4917
4918
4919
4920 // Call the bottleneck
4921 E3System_Bottleneck();
4922
4923
4924
4925 // Call our implementation
4926 return(E3Marker_SetXOffset(marker, xOffset));
4927 }
4928
4929
4930
4931
4932
4933 //=============================================================================
4934 // Q3Marker_GetYOffset : Quesa API entry point.
4935 //-----------------------------------------------------------------------------
4936 TQ3Status
Q3Marker_GetYOffset(TQ3GeometryObject marker,TQ3Int32 * yOffset)4937 Q3Marker_GetYOffset(TQ3GeometryObject marker, TQ3Int32 *yOffset)
4938 {
4939
4940
4941 // Release build checks
4942 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
4943 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(yOffset), kQ3Failure);
4944
4945
4946
4947 // Debug build checks
4948 #if Q3_DEBUG
4949 if (0) // Further checks on marker
4950 return(kQ3Failure);
4951
4952 if (0) // Further checks on yOffset
4953 return(kQ3Failure);
4954 #endif
4955
4956
4957
4958 // Call the bottleneck
4959 E3System_Bottleneck();
4960
4961
4962
4963 // Call our implementation
4964 return(E3Marker_GetYOffset(marker, yOffset));
4965 }
4966
4967
4968
4969
4970
4971 //=============================================================================
4972 // Q3Marker_SetYOffset : Quesa API entry point.
4973 //-----------------------------------------------------------------------------
4974 TQ3Status
Q3Marker_SetYOffset(TQ3GeometryObject marker,TQ3Int32 yOffset)4975 Q3Marker_SetYOffset(TQ3GeometryObject marker, TQ3Int32 yOffset)
4976 {
4977
4978
4979 // Release build checks
4980 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
4981
4982
4983
4984 // Debug build checks
4985 #if Q3_DEBUG
4986 if (0) // Further checks on marker
4987 return(kQ3Failure);
4988
4989 if (0) // Further checks on yOffset
4990 return(kQ3Failure);
4991 #endif
4992
4993
4994
4995 // Call the bottleneck
4996 E3System_Bottleneck();
4997
4998
4999
5000 // Call our implementation
5001 return(E3Marker_SetYOffset(marker, yOffset));
5002 }
5003
5004
5005
5006
5007
5008 //=============================================================================
5009 // Q3Marker_GetBitmap : Quesa API entry point.
5010 //-----------------------------------------------------------------------------
5011 TQ3Status
Q3Marker_GetBitmap(TQ3GeometryObject marker,TQ3Bitmap * bitmap)5012 Q3Marker_GetBitmap(TQ3GeometryObject marker, TQ3Bitmap *bitmap)
5013 {
5014
5015
5016 // Release build checks
5017 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
5018 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(bitmap), kQ3Failure);
5019
5020
5021
5022 // Debug build checks
5023 #if Q3_DEBUG
5024 if (0) // Further checks on marker
5025 return(kQ3Failure);
5026
5027 if (0) // Further checks on bitmap
5028 return(kQ3Failure);
5029 #endif
5030
5031
5032
5033 // Call the bottleneck
5034 E3System_Bottleneck();
5035
5036
5037
5038 // Call our implementation
5039 return(E3Marker_GetBitmap(marker, bitmap));
5040 }
5041
5042
5043
5044
5045
5046 //=============================================================================
5047 // Q3Marker_SetBitmap : Quesa API entry point.
5048 //-----------------------------------------------------------------------------
5049 TQ3Status
Q3Marker_SetBitmap(TQ3GeometryObject marker,const TQ3Bitmap * bitmap)5050 Q3Marker_SetBitmap(TQ3GeometryObject marker, const TQ3Bitmap *bitmap)
5051 {
5052
5053
5054 // Release build checks
5055 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( marker ), kQ3Failure);
5056 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(bitmap), kQ3Failure);
5057
5058
5059
5060 // Debug build checks
5061 #if Q3_DEBUG
5062 if (0) // Further checks on marker
5063 return(kQ3Failure);
5064
5065 if (0) // Further checks on bitmap
5066 return(kQ3Failure);
5067 #endif
5068
5069
5070
5071 // Call the bottleneck
5072 E3System_Bottleneck();
5073
5074
5075
5076 // Call our implementation
5077 return(E3Marker_SetBitmap(marker, bitmap));
5078 }
5079
5080
5081
5082
5083
5084 //=============================================================================
5085 // Q3Mesh_New : Quesa API entry point.
5086 //-----------------------------------------------------------------------------
5087 TQ3GeometryObject
Q3Mesh_New(void)5088 Q3Mesh_New(void)
5089 {
5090
5091
5092 // Call the bottleneck
5093 E3System_Bottleneck();
5094
5095
5096
5097 // Call our implementation
5098 return(E3Mesh_New());
5099 }
5100
5101
5102
5103
5104
5105 //=============================================================================
5106 // Q3Mesh_SetData : Quesa API entry point.
5107 //-----------------------------------------------------------------------------
5108 TQ3Status
Q3Mesh_SetData(TQ3GeometryObject mesh,const TQ3MeshData * meshData)5109 Q3Mesh_SetData(TQ3GeometryObject mesh, const TQ3MeshData *meshData)
5110 {
5111
5112
5113 // Release build checks
5114 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5115 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(meshData), kQ3Failure);
5116
5117
5118
5119 // Debug build checks
5120 #if Q3_DEBUG
5121 if (0) // Further checks on mesh
5122 return(kQ3Failure);
5123
5124 if (0) // Further checks on meshData
5125 return(kQ3Failure);
5126 #endif
5127
5128
5129
5130 // Call the bottleneck
5131 E3System_Bottleneck();
5132
5133
5134
5135 // Call our implementation
5136 return(E3Mesh_SetData(mesh, meshData));
5137 }
5138
5139
5140
5141
5142
5143 //=============================================================================
5144 // Q3Mesh_GetData : Quesa API entry point.
5145 //-----------------------------------------------------------------------------
5146 TQ3Status
Q3Mesh_GetData(TQ3GeometryObject mesh,TQ3MeshData * meshData)5147 Q3Mesh_GetData(TQ3GeometryObject mesh, TQ3MeshData *meshData)
5148 {
5149
5150
5151 // Release build checks
5152 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5153 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(meshData), kQ3Failure);
5154
5155
5156
5157 // Debug build checks
5158 #if Q3_DEBUG
5159 if (0) // Further checks on mesh
5160 return(kQ3Failure);
5161
5162 if (0) // Further checks on meshData
5163 return(kQ3Failure);
5164 #endif
5165
5166
5167
5168 // Call the bottleneck
5169 E3System_Bottleneck();
5170
5171
5172
5173 // Call our implementation
5174 return(E3Mesh_GetData(mesh, meshData));
5175 }
5176
5177
5178
5179
5180
5181 //=============================================================================
5182 // Q3Mesh_EmptyData : Quesa API entry point.
5183 //-----------------------------------------------------------------------------
5184 TQ3Status
Q3Mesh_EmptyData(TQ3MeshData * meshData)5185 Q3Mesh_EmptyData(TQ3MeshData *meshData)
5186 {
5187
5188
5189 // Release build checks
5190 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(meshData), kQ3Failure);
5191
5192
5193
5194 // Debug build checks
5195 #if Q3_DEBUG
5196 if (0) // Further checks on meshData
5197 return(kQ3Failure);
5198 #endif
5199
5200
5201
5202 // Call the bottleneck
5203 E3System_Bottleneck();
5204
5205
5206
5207 // Call our implementation
5208 return(E3Mesh_EmptyData(meshData));
5209 }
5210
5211
5212
5213
5214
5215 //=============================================================================
5216 // Q3Mesh_VertexNew : Quesa API entry point.
5217 //-----------------------------------------------------------------------------
5218 TQ3MeshVertex
Q3Mesh_VertexNew(TQ3GeometryObject mesh,const TQ3Vertex3D * vertex)5219 Q3Mesh_VertexNew(TQ3GeometryObject mesh, const TQ3Vertex3D *vertex)
5220 {
5221
5222
5223 // Release build checks
5224 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
5225 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vertex), NULL);
5226
5227
5228
5229 // Debug build checks
5230 #if Q3_DEBUG
5231 if (0) // Further checks on mesh
5232 return(NULL);
5233
5234 if (0) // Further checks on vertex
5235 return(NULL);
5236 #endif
5237
5238
5239
5240 // Call the bottleneck
5241 E3System_Bottleneck();
5242
5243
5244
5245 // Call our implementation
5246 return(E3Mesh_VertexNew(mesh, vertex));
5247 }
5248
5249
5250
5251
5252
5253 //=============================================================================
5254 // Q3Mesh_FaceNew : Quesa API entry point.
5255 //-----------------------------------------------------------------------------
5256 TQ3MeshFace
Q3Mesh_FaceNew(TQ3GeometryObject mesh,TQ3Uns32 numVertices,const TQ3MeshVertex * vertices,TQ3AttributeSet attributeSet)5257 Q3Mesh_FaceNew(TQ3GeometryObject mesh, TQ3Uns32 numVertices, const TQ3MeshVertex *vertices, TQ3AttributeSet attributeSet)
5258 {
5259
5260
5261 // Release build checks
5262 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
5263 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vertices), NULL);
5264
5265
5266
5267 // Debug build checks
5268 #if Q3_DEBUG
5269 if (0) // Further checks on mesh
5270 return(NULL);
5271
5272 if (0) // Further checks on numVertices
5273 return(NULL);
5274
5275 if (0) // Further checks on vertices
5276 return(NULL);
5277
5278 if (0) // Further checks on attributeSet
5279 return(NULL);
5280 #endif
5281
5282
5283
5284 // Call the bottleneck
5285 E3System_Bottleneck();
5286
5287
5288
5289 // Call our implementation
5290 return(E3Mesh_FaceNew(mesh, numVertices, vertices, attributeSet));
5291 }
5292
5293
5294
5295
5296
5297 //=============================================================================
5298 // Q3Mesh_VertexDelete : Quesa API entry point.
5299 //-----------------------------------------------------------------------------
5300 TQ3Status
Q3Mesh_VertexDelete(TQ3GeometryObject mesh,TQ3MeshVertex vertex)5301 Q3Mesh_VertexDelete(TQ3GeometryObject mesh, TQ3MeshVertex vertex)
5302 {
5303
5304
5305 // Release build checks
5306 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5307
5308
5309
5310 // Debug build checks
5311 #if Q3_DEBUG
5312 if (0) // Further checks on mesh
5313 return(kQ3Failure);
5314
5315 if (0) // Further checks on vertex
5316 return(kQ3Failure);
5317 #endif
5318
5319
5320
5321 // Call the bottleneck
5322 E3System_Bottleneck();
5323
5324
5325
5326 // Call our implementation
5327 return(E3Mesh_VertexDelete(mesh, vertex));
5328 }
5329
5330
5331
5332
5333
5334 //=============================================================================
5335 // Q3Mesh_FaceDelete : Quesa API entry point.
5336 //-----------------------------------------------------------------------------
5337 TQ3Status
Q3Mesh_FaceDelete(TQ3GeometryObject mesh,TQ3MeshFace face)5338 Q3Mesh_FaceDelete(TQ3GeometryObject mesh, TQ3MeshFace face)
5339 {
5340
5341
5342 // Release build checks
5343 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5344
5345
5346
5347 // Debug build checks
5348 #if Q3_DEBUG
5349 if (0) // Further checks on mesh
5350 return(kQ3Failure);
5351
5352 if (0) // Further checks on face
5353 return(kQ3Failure);
5354 #endif
5355
5356
5357
5358 // Call the bottleneck
5359 E3System_Bottleneck();
5360
5361
5362
5363 // Call our implementation
5364 return(E3Mesh_FaceDelete(mesh, face));
5365 }
5366
5367
5368
5369
5370
5371 //=============================================================================
5372 // Q3Mesh_DelayUpdates : Quesa API entry point.
5373 //-----------------------------------------------------------------------------
5374 TQ3Status
Q3Mesh_DelayUpdates(TQ3GeometryObject mesh)5375 Q3Mesh_DelayUpdates(TQ3GeometryObject mesh)
5376 {
5377
5378
5379 // Release build checks
5380 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5381
5382
5383
5384 // Debug build checks
5385 #if Q3_DEBUG
5386 if (0) // Further checks on mesh
5387 return(kQ3Failure);
5388 #endif
5389
5390
5391
5392 // Call the bottleneck
5393 E3System_Bottleneck();
5394
5395
5396
5397 // Call our implementation
5398 return(E3Mesh_DelayUpdates(mesh));
5399 }
5400
5401
5402
5403
5404
5405 //=============================================================================
5406 // Q3Mesh_ResumeUpdates : Quesa API entry point.
5407 //-----------------------------------------------------------------------------
5408 TQ3Status
Q3Mesh_ResumeUpdates(TQ3GeometryObject mesh)5409 Q3Mesh_ResumeUpdates(TQ3GeometryObject mesh)
5410 {
5411
5412
5413 // Release build checks
5414 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5415
5416
5417
5418 // Debug build checks
5419 #if Q3_DEBUG
5420 if (0) // Further checks on mesh
5421 return(kQ3Failure);
5422 #endif
5423
5424
5425
5426 // Call the bottleneck
5427 E3System_Bottleneck();
5428
5429
5430
5431 // Call our implementation
5432 return(E3Mesh_ResumeUpdates(mesh));
5433 }
5434
5435
5436
5437
5438
5439 //=============================================================================
5440 // Q3Mesh_FaceToContour : Quesa API entry point.
5441 //-----------------------------------------------------------------------------
5442 TQ3MeshContour
Q3Mesh_FaceToContour(TQ3GeometryObject mesh,TQ3MeshFace containerFace,TQ3MeshFace face)5443 Q3Mesh_FaceToContour(TQ3GeometryObject mesh, TQ3MeshFace containerFace, TQ3MeshFace face)
5444 {
5445
5446
5447 // Release build checks
5448 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
5449
5450
5451
5452 // Debug build checks
5453 #if Q3_DEBUG
5454 if (0) // Further checks on mesh
5455 return(NULL);
5456
5457 if (0) // Further checks on containerFace
5458 return(NULL);
5459
5460 if (0) // Further checks on face
5461 return(NULL);
5462 #endif
5463
5464
5465
5466 // Call the bottleneck
5467 E3System_Bottleneck();
5468
5469
5470
5471 // Call our implementation
5472 return(E3Mesh_FaceToContour(mesh, containerFace, face));
5473 }
5474
5475
5476
5477
5478
5479 //=============================================================================
5480 // Q3Mesh_ContourToFace : Quesa API entry point.
5481 //-----------------------------------------------------------------------------
5482 TQ3MeshFace
Q3Mesh_ContourToFace(TQ3GeometryObject mesh,TQ3MeshContour contour)5483 Q3Mesh_ContourToFace(TQ3GeometryObject mesh, TQ3MeshContour contour)
5484 {
5485
5486
5487 // Release build checks
5488 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
5489
5490
5491
5492 // Debug build checks
5493 #if Q3_DEBUG
5494 if (0) // Further checks on mesh
5495 return(NULL);
5496
5497 if (0) // Further checks on contour
5498 return(NULL);
5499 #endif
5500
5501
5502
5503 // Call the bottleneck
5504 E3System_Bottleneck();
5505
5506
5507
5508 // Call our implementation
5509 return(E3Mesh_ContourToFace(mesh, contour));
5510 }
5511
5512
5513
5514
5515
5516 //=============================================================================
5517 // Q3Mesh_GetNumComponents : Quesa API entry point.
5518 //-----------------------------------------------------------------------------
5519 TQ3Status
Q3Mesh_GetNumComponents(TQ3GeometryObject mesh,TQ3Uns32 * numComponents)5520 Q3Mesh_GetNumComponents(TQ3GeometryObject mesh, TQ3Uns32 *numComponents)
5521 {
5522
5523
5524 // Release build checks
5525 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5526 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numComponents), kQ3Failure);
5527
5528
5529
5530 // Debug build checks
5531 #if Q3_DEBUG
5532 if (0) // Further checks on mesh
5533 return(kQ3Failure);
5534
5535 if (0) // Further checks on numComponents
5536 return(kQ3Failure);
5537 #endif
5538
5539
5540
5541 // Call the bottleneck
5542 E3System_Bottleneck();
5543
5544
5545
5546 // Call our implementation
5547 return(E3Mesh_GetNumComponents(mesh, numComponents));
5548 }
5549
5550
5551
5552
5553
5554 //=============================================================================
5555 // Q3Mesh_GetNumEdges : Quesa API entry point.
5556 //-----------------------------------------------------------------------------
5557 TQ3Status
Q3Mesh_GetNumEdges(TQ3GeometryObject mesh,TQ3Uns32 * numEdges)5558 Q3Mesh_GetNumEdges(TQ3GeometryObject mesh, TQ3Uns32 *numEdges)
5559 {
5560
5561
5562 // Release build checks
5563 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5564 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numEdges), kQ3Failure);
5565
5566
5567
5568 // Debug build checks
5569 #if Q3_DEBUG
5570 if (0) // Further checks on mesh
5571 return(kQ3Failure);
5572
5573 if (0) // Further checks on numEdges
5574 return(kQ3Failure);
5575 #endif
5576
5577
5578
5579 // Call the bottleneck
5580 E3System_Bottleneck();
5581
5582
5583
5584 // Call our implementation
5585 return(E3Mesh_GetNumEdges(mesh, numEdges));
5586 }
5587
5588
5589
5590
5591
5592 //=============================================================================
5593 // Q3Mesh_GetNumVertices : Quesa API entry point.
5594 //-----------------------------------------------------------------------------
5595 TQ3Status
Q3Mesh_GetNumVertices(TQ3GeometryObject mesh,TQ3Uns32 * numVertices)5596 Q3Mesh_GetNumVertices(TQ3GeometryObject mesh, TQ3Uns32 *numVertices)
5597 {
5598
5599
5600 // Release build checks
5601 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5602 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numVertices), kQ3Failure);
5603
5604
5605
5606 // Debug build checks
5607 #if Q3_DEBUG
5608 if (0) // Further checks on mesh
5609 return(kQ3Failure);
5610
5611 if (0) // Further checks on numVertices
5612 return(kQ3Failure);
5613 #endif
5614
5615
5616
5617 // Call the bottleneck
5618 E3System_Bottleneck();
5619
5620
5621
5622 // Call our implementation
5623 return(E3Mesh_GetNumVertices(mesh, numVertices));
5624 }
5625
5626
5627
5628
5629
5630 //=============================================================================
5631 // Q3Mesh_GetNumFaces : Quesa API entry point.
5632 //-----------------------------------------------------------------------------
5633 TQ3Status
Q3Mesh_GetNumFaces(TQ3GeometryObject mesh,TQ3Uns32 * numFaces)5634 Q3Mesh_GetNumFaces(TQ3GeometryObject mesh, TQ3Uns32 *numFaces)
5635 {
5636
5637
5638 // Release build checks
5639 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5640 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numFaces), kQ3Failure);
5641
5642
5643
5644 // Debug build checks
5645 #if Q3_DEBUG
5646 if (0) // Further checks on mesh
5647 return(kQ3Failure);
5648
5649 if (0) // Further checks on numFaces
5650 return(kQ3Failure);
5651 #endif
5652
5653
5654
5655 // Call the bottleneck
5656 E3System_Bottleneck();
5657
5658
5659
5660 // Call our implementation
5661 return(E3Mesh_GetNumFaces(mesh, numFaces));
5662 }
5663
5664
5665
5666
5667
5668 //=============================================================================
5669 // Q3Mesh_GetNumCorners : Quesa API entry point.
5670 //-----------------------------------------------------------------------------
5671 TQ3Status
Q3Mesh_GetNumCorners(TQ3GeometryObject mesh,TQ3Uns32 * numCorners)5672 Q3Mesh_GetNumCorners(TQ3GeometryObject mesh, TQ3Uns32 *numCorners)
5673 {
5674
5675
5676 // Release build checks
5677 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5678 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numCorners), kQ3Failure);
5679
5680
5681
5682 // Debug build checks
5683 #if Q3_DEBUG
5684 if (0) // Further checks on mesh
5685 return(kQ3Failure);
5686
5687 if (0) // Further checks on numCorners
5688 return(kQ3Failure);
5689 #endif
5690
5691
5692
5693 // Call the bottleneck
5694 E3System_Bottleneck();
5695
5696
5697
5698 // Call our implementation
5699 return(E3Mesh_GetNumCorners(mesh, numCorners));
5700 }
5701
5702
5703
5704
5705
5706 //=============================================================================
5707 // Q3Mesh_GetOrientable : Quesa API entry point.
5708 //-----------------------------------------------------------------------------
5709 TQ3Status
Q3Mesh_GetOrientable(TQ3GeometryObject mesh,TQ3Boolean * orientable)5710 Q3Mesh_GetOrientable(TQ3GeometryObject mesh, TQ3Boolean *orientable)
5711 {
5712
5713
5714 // Release build checks
5715 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5716 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientable), kQ3Failure);
5717
5718
5719
5720 // Debug build checks
5721 #if Q3_DEBUG
5722 if (0) // Further checks on mesh
5723 return(kQ3Failure);
5724
5725 if (0) // Further checks on orientable
5726 return(kQ3Failure);
5727 #endif
5728
5729
5730
5731 // Call the bottleneck
5732 E3System_Bottleneck();
5733
5734
5735
5736 // Call our implementation
5737 return(E3Mesh_GetOrientable(mesh, orientable));
5738 }
5739
5740
5741
5742
5743
5744 //=============================================================================
5745 // Q3Mesh_GetComponentNumVertices : Quesa API entry point.
5746 //-----------------------------------------------------------------------------
5747 TQ3Status
Q3Mesh_GetComponentNumVertices(TQ3GeometryObject mesh,TQ3MeshComponent component,TQ3Uns32 * numVertices)5748 Q3Mesh_GetComponentNumVertices(TQ3GeometryObject mesh, TQ3MeshComponent component, TQ3Uns32 *numVertices)
5749 {
5750
5751
5752 // Release build checks
5753 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5754 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numVertices), kQ3Failure);
5755
5756
5757
5758 // Debug build checks
5759 #if Q3_DEBUG
5760 if (0) // Further checks on mesh
5761 return(kQ3Failure);
5762
5763 if (0) // Further checks on component
5764 return(kQ3Failure);
5765
5766 if (0) // Further checks on numVertices
5767 return(kQ3Failure);
5768 #endif
5769
5770
5771
5772 // Call the bottleneck
5773 E3System_Bottleneck();
5774
5775
5776
5777 // Call our implementation
5778 return(E3Mesh_GetComponentNumVertices(mesh, component, numVertices));
5779 }
5780
5781
5782
5783
5784
5785 //=============================================================================
5786 // Q3Mesh_GetComponentNumEdges : Quesa API entry point.
5787 //-----------------------------------------------------------------------------
5788 TQ3Status
Q3Mesh_GetComponentNumEdges(TQ3GeometryObject mesh,TQ3MeshComponent component,TQ3Uns32 * numEdges)5789 Q3Mesh_GetComponentNumEdges(TQ3GeometryObject mesh, TQ3MeshComponent component, TQ3Uns32 *numEdges)
5790 {
5791
5792
5793 // Release build checks
5794 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5795 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numEdges), kQ3Failure);
5796
5797
5798
5799 // Debug build checks
5800 #if Q3_DEBUG
5801 if (0) // Further checks on mesh
5802 return(kQ3Failure);
5803
5804 if (0) // Further checks on component
5805 return(kQ3Failure);
5806
5807 if (0) // Further checks on numEdges
5808 return(kQ3Failure);
5809 #endif
5810
5811
5812
5813 // Call the bottleneck
5814 E3System_Bottleneck();
5815
5816
5817
5818 // Call our implementation
5819 return(E3Mesh_GetComponentNumEdges(mesh, component, numEdges));
5820 }
5821
5822
5823
5824
5825
5826 //=============================================================================
5827 // Q3Mesh_GetComponentBoundingBox : Quesa API entry point.
5828 //-----------------------------------------------------------------------------
5829 TQ3Status
Q3Mesh_GetComponentBoundingBox(TQ3GeometryObject mesh,TQ3MeshComponent component,TQ3BoundingBox * boundingBox)5830 Q3Mesh_GetComponentBoundingBox(TQ3GeometryObject mesh, TQ3MeshComponent component, TQ3BoundingBox *boundingBox)
5831 {
5832
5833
5834 // Release build checks
5835 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5836 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(boundingBox), kQ3Failure);
5837
5838
5839
5840 // Debug build checks
5841 #if Q3_DEBUG
5842 if (0) // Further checks on mesh
5843 return(kQ3Failure);
5844
5845 if (0) // Further checks on component
5846 return(kQ3Failure);
5847
5848 if (0) // Further checks on boundingBox
5849 return(kQ3Failure);
5850 #endif
5851
5852
5853
5854 // Call the bottleneck
5855 E3System_Bottleneck();
5856
5857
5858
5859 // Call our implementation
5860 return(E3Mesh_GetComponentBoundingBox(mesh, component, boundingBox));
5861 }
5862
5863
5864
5865
5866
5867 //=============================================================================
5868 // Q3Mesh_GetComponentOrientable : Quesa API entry point.
5869 //-----------------------------------------------------------------------------
5870 TQ3Status
Q3Mesh_GetComponentOrientable(TQ3GeometryObject mesh,TQ3MeshComponent component,TQ3Boolean * orientable)5871 Q3Mesh_GetComponentOrientable(TQ3GeometryObject mesh, TQ3MeshComponent component, TQ3Boolean *orientable)
5872 {
5873
5874
5875 // Release build checks
5876 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5877 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientable), kQ3Failure);
5878
5879
5880
5881 // Debug build checks
5882 #if Q3_DEBUG
5883 if (0) // Further checks on mesh
5884 return(kQ3Failure);
5885
5886 if (0) // Further checks on component
5887 return(kQ3Failure);
5888
5889 if (0) // Further checks on orientable
5890 return(kQ3Failure);
5891 #endif
5892
5893
5894
5895 // Call the bottleneck
5896 E3System_Bottleneck();
5897
5898
5899
5900 // Call our implementation
5901 return(E3Mesh_GetComponentOrientable(mesh, component, orientable));
5902 }
5903
5904
5905
5906
5907
5908 //=============================================================================
5909 // Q3Mesh_GetVertexCoordinates : Quesa API entry point.
5910 //-----------------------------------------------------------------------------
5911 TQ3Status
Q3Mesh_GetVertexCoordinates(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3Point3D * coordinates)5912 Q3Mesh_GetVertexCoordinates(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3Point3D *coordinates)
5913 {
5914
5915
5916 // Release build checks
5917 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5918 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coordinates), kQ3Failure);
5919
5920
5921
5922 // Debug build checks
5923 #if Q3_DEBUG
5924 if (0) // Further checks on mesh
5925 return(kQ3Failure);
5926
5927 if (0) // Further checks on vertex
5928 return(kQ3Failure);
5929
5930 if (0) // Further checks on coordinates
5931 return(kQ3Failure);
5932 #endif
5933
5934
5935
5936 // Call the bottleneck
5937 E3System_Bottleneck();
5938
5939
5940
5941 // Call our implementation
5942 return(E3Mesh_GetVertexCoordinates(mesh, vertex, coordinates));
5943 }
5944
5945
5946
5947
5948
5949 //=============================================================================
5950 // Q3Mesh_GetVertexIndex : Quesa API entry point.
5951 //-----------------------------------------------------------------------------
5952 TQ3Status
Q3Mesh_GetVertexIndex(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3Uns32 * index)5953 Q3Mesh_GetVertexIndex(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3Uns32 *index)
5954 {
5955
5956
5957 // Release build checks
5958 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
5959 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(index), kQ3Failure);
5960
5961
5962
5963 // Debug build checks
5964 #if Q3_DEBUG
5965 if (0) // Further checks on mesh
5966 return(kQ3Failure);
5967
5968 if (0) // Further checks on vertex
5969 return(kQ3Failure);
5970
5971 if (0) // Further checks on index
5972 return(kQ3Failure);
5973 #endif
5974
5975
5976
5977 // Call the bottleneck
5978 E3System_Bottleneck();
5979
5980
5981
5982 // Call our implementation
5983 return(E3Mesh_GetVertexIndex(mesh, vertex, index));
5984 }
5985
5986
5987
5988
5989
5990 //=============================================================================
5991 // Q3Mesh_GetVertexOnBoundary : Quesa API entry point.
5992 //-----------------------------------------------------------------------------
5993 TQ3Status
Q3Mesh_GetVertexOnBoundary(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3Boolean * onBoundary)5994 Q3Mesh_GetVertexOnBoundary(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3Boolean *onBoundary)
5995 {
5996
5997
5998 // Release build checks
5999 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6000 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(onBoundary), kQ3Failure);
6001
6002
6003
6004 // Debug build checks
6005 #if Q3_DEBUG
6006 if (0) // Further checks on mesh
6007 return(kQ3Failure);
6008
6009 if (0) // Further checks on vertex
6010 return(kQ3Failure);
6011
6012 if (0) // Further checks on onBoundary
6013 return(kQ3Failure);
6014 #endif
6015
6016
6017
6018 // Call the bottleneck
6019 E3System_Bottleneck();
6020
6021
6022
6023 // Call our implementation
6024 return(E3Mesh_GetVertexOnBoundary(mesh, vertex, onBoundary));
6025 }
6026
6027
6028
6029
6030
6031 //=============================================================================
6032 // Q3Mesh_GetVertexComponent : Quesa API entry point.
6033 //-----------------------------------------------------------------------------
6034 TQ3Status
Q3Mesh_GetVertexComponent(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3MeshComponent * component)6035 Q3Mesh_GetVertexComponent(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3MeshComponent *component)
6036 {
6037
6038
6039 // Release build checks
6040 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6041 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(component), kQ3Failure);
6042
6043
6044
6045 // Debug build checks
6046 #if Q3_DEBUG
6047 if (0) // Further checks on mesh
6048 return(kQ3Failure);
6049
6050 if (0) // Further checks on vertex
6051 return(kQ3Failure);
6052
6053 if (0) // Further checks on component
6054 return(kQ3Failure);
6055 #endif
6056
6057
6058
6059 // Call the bottleneck
6060 E3System_Bottleneck();
6061
6062
6063
6064 // Call our implementation
6065 return(E3Mesh_GetVertexComponent(mesh, vertex, component));
6066 }
6067
6068
6069
6070
6071
6072 //=============================================================================
6073 // Q3Mesh_GetVertexAttributeSet : Quesa API entry point.
6074 //-----------------------------------------------------------------------------
6075 TQ3Status
Q3Mesh_GetVertexAttributeSet(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3AttributeSet * attributeSet)6076 Q3Mesh_GetVertexAttributeSet(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3AttributeSet *attributeSet)
6077 {
6078
6079
6080 // Release build checks
6081 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6082 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
6083
6084
6085
6086 // Debug build checks
6087 #if Q3_DEBUG
6088 if (0) // Further checks on mesh
6089 return(kQ3Failure);
6090
6091 if (0) // Further checks on vertex
6092 return(kQ3Failure);
6093
6094 if (0) // Further checks on attributeSet
6095 return(kQ3Failure);
6096 #endif
6097
6098
6099
6100 // Call the bottleneck
6101 E3System_Bottleneck();
6102
6103
6104
6105 // Call our implementation
6106 return(E3Mesh_GetVertexAttributeSet(mesh, vertex, attributeSet));
6107 }
6108
6109
6110
6111
6112
6113 //=============================================================================
6114 // Q3Mesh_SetVertexCoordinates : Quesa API entry point.
6115 //-----------------------------------------------------------------------------
6116 TQ3Status
Q3Mesh_SetVertexCoordinates(TQ3GeometryObject mesh,TQ3MeshVertex vertex,const TQ3Point3D * coordinates)6117 Q3Mesh_SetVertexCoordinates(TQ3GeometryObject mesh, TQ3MeshVertex vertex, const TQ3Point3D *coordinates)
6118 {
6119
6120
6121 // Release build checks
6122 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6123 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(coordinates), kQ3Failure);
6124
6125
6126
6127 // Debug build checks
6128 #if Q3_DEBUG
6129 if (0) // Further checks on mesh
6130 return(kQ3Failure);
6131
6132 if (0) // Further checks on vertex
6133 return(kQ3Failure);
6134
6135 if (0) // Further checks on coordinates
6136 return(kQ3Failure);
6137 #endif
6138
6139
6140
6141 // Call the bottleneck
6142 E3System_Bottleneck();
6143
6144
6145
6146 // Call our implementation
6147 return(E3Mesh_SetVertexCoordinates(mesh, vertex, coordinates));
6148 }
6149
6150
6151
6152
6153
6154 //=============================================================================
6155 // Q3Mesh_SetVertexAttributeSet : Quesa API entry point.
6156 //-----------------------------------------------------------------------------
6157 TQ3Status
Q3Mesh_SetVertexAttributeSet(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3AttributeSet attributeSet)6158 Q3Mesh_SetVertexAttributeSet(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3AttributeSet attributeSet)
6159 {
6160
6161
6162 // Release build checks
6163 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6164
6165
6166
6167 // Debug build checks
6168 #if Q3_DEBUG
6169 if (0) // Further checks on mesh
6170 return(kQ3Failure);
6171
6172 if (0) // Further checks on vertex
6173 return(kQ3Failure);
6174
6175 if (0) // Further checks on attributeSet
6176 return(kQ3Failure);
6177 #endif
6178
6179
6180
6181 // Call the bottleneck
6182 E3System_Bottleneck();
6183
6184
6185
6186 // Call our implementation
6187 return(E3Mesh_SetVertexAttributeSet(mesh, vertex, attributeSet));
6188 }
6189
6190
6191
6192
6193
6194 //=============================================================================
6195 // Q3Mesh_GetFaceNumVertices : Quesa API entry point.
6196 //-----------------------------------------------------------------------------
6197 TQ3Status
Q3Mesh_GetFaceNumVertices(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3Uns32 * numVertices)6198 Q3Mesh_GetFaceNumVertices(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3Uns32 *numVertices)
6199 {
6200
6201
6202 // Release build checks
6203 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6204 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numVertices), kQ3Failure);
6205
6206
6207
6208 // Debug build checks
6209 #if Q3_DEBUG
6210 if (0) // Further checks on mesh
6211 return(kQ3Failure);
6212
6213 if (0) // Further checks on face
6214 return(kQ3Failure);
6215
6216 if (0) // Further checks on numVertices
6217 return(kQ3Failure);
6218 #endif
6219
6220
6221
6222 // Call the bottleneck
6223 E3System_Bottleneck();
6224
6225
6226
6227 // Call our implementation
6228 return(E3Mesh_GetFaceNumVertices(mesh, face, numVertices));
6229 }
6230
6231
6232
6233
6234
6235 //=============================================================================
6236 // Q3Mesh_GetFacePlaneEquation : Quesa API entry point.
6237 //-----------------------------------------------------------------------------
6238 TQ3Status
Q3Mesh_GetFacePlaneEquation(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3PlaneEquation * planeEquation)6239 Q3Mesh_GetFacePlaneEquation(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3PlaneEquation *planeEquation)
6240 {
6241
6242
6243 // Release build checks
6244 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6245 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(planeEquation), kQ3Failure);
6246
6247
6248
6249 // Debug build checks
6250 #if Q3_DEBUG
6251 if (0) // Further checks on mesh
6252 return(kQ3Failure);
6253
6254 if (0) // Further checks on face
6255 return(kQ3Failure);
6256
6257 if (0) // Further checks on planeEquation
6258 return(kQ3Failure);
6259 #endif
6260
6261
6262
6263 // Call the bottleneck
6264 E3System_Bottleneck();
6265
6266
6267
6268 // Call our implementation
6269 return(E3Mesh_GetFacePlaneEquation(mesh, face, planeEquation));
6270 }
6271
6272
6273
6274
6275
6276 //=============================================================================
6277 // Q3Mesh_GetFaceNumContours : Quesa API entry point.
6278 //-----------------------------------------------------------------------------
6279 TQ3Status
Q3Mesh_GetFaceNumContours(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3Uns32 * numContours)6280 Q3Mesh_GetFaceNumContours(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3Uns32 *numContours)
6281 {
6282
6283
6284 // Release build checks
6285 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6286 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numContours), kQ3Failure);
6287
6288
6289
6290 // Debug build checks
6291 #if Q3_DEBUG
6292 if (0) // Further checks on mesh
6293 return(kQ3Failure);
6294
6295 if (0) // Further checks on face
6296 return(kQ3Failure);
6297
6298 if (0) // Further checks on numContours
6299 return(kQ3Failure);
6300 #endif
6301
6302
6303
6304 // Call the bottleneck
6305 E3System_Bottleneck();
6306
6307
6308
6309 // Call our implementation
6310 return(E3Mesh_GetFaceNumContours(mesh, face, numContours));
6311 }
6312
6313
6314
6315
6316
6317 //=============================================================================
6318 // Q3Mesh_GetFaceIndex : Quesa API entry point.
6319 //-----------------------------------------------------------------------------
6320 TQ3Status
Q3Mesh_GetFaceIndex(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3Uns32 * index)6321 Q3Mesh_GetFaceIndex(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3Uns32 *index)
6322 {
6323
6324
6325 // Release build checks
6326 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6327 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(index), kQ3Failure);
6328
6329
6330
6331 // Debug build checks
6332 #if Q3_DEBUG
6333 if (0) // Further checks on mesh
6334 return(kQ3Failure);
6335
6336 if (0) // Further checks on face
6337 return(kQ3Failure);
6338
6339 if (0) // Further checks on index
6340 return(kQ3Failure);
6341 #endif
6342
6343
6344
6345 // Call the bottleneck
6346 E3System_Bottleneck();
6347
6348
6349
6350 // Call our implementation
6351 return(E3Mesh_GetFaceIndex(mesh, face, index));
6352 }
6353
6354
6355
6356
6357
6358 //=============================================================================
6359 // Q3Mesh_GetFaceComponent : Quesa API entry point.
6360 //-----------------------------------------------------------------------------
6361 TQ3Status
Q3Mesh_GetFaceComponent(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3MeshComponent * component)6362 Q3Mesh_GetFaceComponent(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3MeshComponent *component)
6363 {
6364
6365
6366 // Release build checks
6367 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6368 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(component), kQ3Failure);
6369
6370
6371
6372 // Debug build checks
6373 #if Q3_DEBUG
6374 if (0) // Further checks on mesh
6375 return(kQ3Failure);
6376
6377 if (0) // Further checks on face
6378 return(kQ3Failure);
6379
6380 if (0) // Further checks on component
6381 return(kQ3Failure);
6382 #endif
6383
6384
6385
6386 // Call the bottleneck
6387 E3System_Bottleneck();
6388
6389
6390
6391 // Call our implementation
6392 return(E3Mesh_GetFaceComponent(mesh, face, component));
6393 }
6394
6395
6396
6397
6398
6399 //=============================================================================
6400 // Q3Mesh_GetFaceAttributeSet : Quesa API entry point.
6401 //-----------------------------------------------------------------------------
6402 TQ3Status
Q3Mesh_GetFaceAttributeSet(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3AttributeSet * attributeSet)6403 Q3Mesh_GetFaceAttributeSet(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3AttributeSet *attributeSet)
6404 {
6405
6406
6407 // Release build checks
6408 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6409 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
6410
6411
6412
6413 // Debug build checks
6414 #if Q3_DEBUG
6415 if (0) // Further checks on mesh
6416 return(kQ3Failure);
6417
6418 if (0) // Further checks on face
6419 return(kQ3Failure);
6420
6421 if (0) // Further checks on attributeSet
6422 return(kQ3Failure);
6423 #endif
6424
6425
6426
6427 // Call the bottleneck
6428 E3System_Bottleneck();
6429
6430
6431
6432 // Call our implementation
6433 return(E3Mesh_GetFaceAttributeSet(mesh, face, attributeSet));
6434 }
6435
6436
6437
6438
6439
6440 //=============================================================================
6441 // Q3Mesh_SetFaceAttributeSet : Quesa API entry point.
6442 //-----------------------------------------------------------------------------
6443 TQ3Status
Q3Mesh_SetFaceAttributeSet(TQ3GeometryObject mesh,TQ3MeshFace face,TQ3AttributeSet attributeSet)6444 Q3Mesh_SetFaceAttributeSet(TQ3GeometryObject mesh, TQ3MeshFace face, TQ3AttributeSet attributeSet)
6445 {
6446
6447
6448 // Release build checks
6449 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6450
6451
6452
6453 // Debug build checks
6454 #if Q3_DEBUG
6455 if (0) // Further checks on mesh
6456 return(kQ3Failure);
6457
6458 if (0) // Further checks on face
6459 return(kQ3Failure);
6460
6461 if (0) // Further checks on attributeSet
6462 return(kQ3Failure);
6463 #endif
6464
6465
6466
6467 // Call the bottleneck
6468 E3System_Bottleneck();
6469
6470
6471
6472 // Call our implementation
6473 return(E3Mesh_SetFaceAttributeSet(mesh, face, attributeSet));
6474 }
6475
6476
6477
6478
6479
6480 //=============================================================================
6481 // Q3Mesh_GetEdgeVertices : Quesa API entry point.
6482 //-----------------------------------------------------------------------------
6483 TQ3Status
Q3Mesh_GetEdgeVertices(TQ3GeometryObject mesh,TQ3MeshEdge edge,TQ3MeshVertex * vertex1,TQ3MeshVertex * vertex2)6484 Q3Mesh_GetEdgeVertices(TQ3GeometryObject mesh, TQ3MeshEdge edge, TQ3MeshVertex *vertex1, TQ3MeshVertex *vertex2)
6485 {
6486
6487
6488 // Release build checks
6489 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6490 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vertex1), kQ3Failure);
6491 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vertex2), kQ3Failure);
6492
6493
6494
6495 // Debug build checks
6496 #if Q3_DEBUG
6497 if (0) // Further checks on mesh
6498 return(kQ3Failure);
6499
6500 if (0) // Further checks on edge
6501 return(kQ3Failure);
6502
6503 if (0) // Further checks on vertex1
6504 return(kQ3Failure);
6505
6506 if (0) // Further checks on vertex2
6507 return(kQ3Failure);
6508 #endif
6509
6510
6511
6512 // Call the bottleneck
6513 E3System_Bottleneck();
6514
6515
6516
6517 // Call our implementation
6518 return(E3Mesh_GetEdgeVertices(mesh, edge, vertex1, vertex2));
6519 }
6520
6521
6522
6523
6524
6525 //=============================================================================
6526 // Q3Mesh_GetEdgeFaces : Quesa API entry point.
6527 //-----------------------------------------------------------------------------
6528 TQ3Status
Q3Mesh_GetEdgeFaces(TQ3GeometryObject mesh,TQ3MeshEdge edge,TQ3MeshFace * face1,TQ3MeshFace * face2)6529 Q3Mesh_GetEdgeFaces(TQ3GeometryObject mesh, TQ3MeshEdge edge, TQ3MeshFace *face1, TQ3MeshFace *face2)
6530 {
6531
6532
6533 // Release build checks
6534 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6535 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(face1), kQ3Failure);
6536 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(face2), kQ3Failure);
6537
6538
6539
6540 // Debug build checks
6541 #if Q3_DEBUG
6542 if (0) // Further checks on mesh
6543 return(kQ3Failure);
6544
6545 if (0) // Further checks on edge
6546 return(kQ3Failure);
6547
6548 if (0) // Further checks on face1
6549 return(kQ3Failure);
6550
6551 if (0) // Further checks on face2
6552 return(kQ3Failure);
6553 #endif
6554
6555
6556
6557 // Call the bottleneck
6558 E3System_Bottleneck();
6559
6560
6561
6562 // Call our implementation
6563 return(E3Mesh_GetEdgeFaces(mesh, edge, face1, face2));
6564 }
6565
6566
6567
6568
6569
6570 //=============================================================================
6571 // Q3Mesh_GetEdgeOnBoundary : Quesa API entry point.
6572 //-----------------------------------------------------------------------------
6573 TQ3Status
Q3Mesh_GetEdgeOnBoundary(TQ3GeometryObject mesh,TQ3MeshEdge edge,TQ3Boolean * onBoundary)6574 Q3Mesh_GetEdgeOnBoundary(TQ3GeometryObject mesh, TQ3MeshEdge edge, TQ3Boolean *onBoundary)
6575 {
6576
6577
6578 // Release build checks
6579 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6580 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(onBoundary), kQ3Failure);
6581
6582
6583
6584 // Debug build checks
6585 #if Q3_DEBUG
6586 if (0) // Further checks on mesh
6587 return(kQ3Failure);
6588
6589 if (0) // Further checks on edge
6590 return(kQ3Failure);
6591
6592 if (0) // Further checks on onBoundary
6593 return(kQ3Failure);
6594 #endif
6595
6596
6597
6598 // Call the bottleneck
6599 E3System_Bottleneck();
6600
6601
6602
6603 // Call our implementation
6604 return(E3Mesh_GetEdgeOnBoundary(mesh, edge, onBoundary));
6605 }
6606
6607
6608
6609
6610
6611 //=============================================================================
6612 // Q3Mesh_GetEdgeComponent : Quesa API entry point.
6613 //-----------------------------------------------------------------------------
6614 TQ3Status
Q3Mesh_GetEdgeComponent(TQ3GeometryObject mesh,TQ3MeshEdge edge,TQ3MeshComponent * component)6615 Q3Mesh_GetEdgeComponent(TQ3GeometryObject mesh, TQ3MeshEdge edge, TQ3MeshComponent *component)
6616 {
6617
6618
6619 // Release build checks
6620 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6621 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(component), kQ3Failure);
6622
6623
6624
6625 // Debug build checks
6626 #if Q3_DEBUG
6627 if (0) // Further checks on mesh
6628 return(kQ3Failure);
6629
6630 if (0) // Further checks on edge
6631 return(kQ3Failure);
6632
6633 if (0) // Further checks on component
6634 return(kQ3Failure);
6635 #endif
6636
6637
6638
6639 // Call the bottleneck
6640 E3System_Bottleneck();
6641
6642
6643
6644 // Call our implementation
6645 return(E3Mesh_GetEdgeComponent(mesh, edge, component));
6646 }
6647
6648
6649
6650
6651
6652 //=============================================================================
6653 // Q3Mesh_GetEdgeAttributeSet : Quesa API entry point.
6654 //-----------------------------------------------------------------------------
6655 TQ3Status
Q3Mesh_GetEdgeAttributeSet(TQ3GeometryObject mesh,TQ3MeshEdge edge,TQ3AttributeSet * attributeSet)6656 Q3Mesh_GetEdgeAttributeSet(TQ3GeometryObject mesh, TQ3MeshEdge edge, TQ3AttributeSet *attributeSet)
6657 {
6658
6659
6660 // Release build checks
6661 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6662 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
6663
6664
6665
6666 // Debug build checks
6667 #if Q3_DEBUG
6668 if (0) // Further checks on mesh
6669 return(kQ3Failure);
6670
6671 if (0) // Further checks on edge
6672 return(kQ3Failure);
6673
6674 if (0) // Further checks on attributeSet
6675 return(kQ3Failure);
6676 #endif
6677
6678
6679
6680 // Call the bottleneck
6681 E3System_Bottleneck();
6682
6683
6684
6685 // Call our implementation
6686 return(E3Mesh_GetEdgeAttributeSet(mesh, edge, attributeSet));
6687 }
6688
6689
6690
6691
6692
6693 //=============================================================================
6694 // Q3Mesh_SetEdgeAttributeSet : Quesa API entry point.
6695 //-----------------------------------------------------------------------------
6696 TQ3Status
Q3Mesh_SetEdgeAttributeSet(TQ3GeometryObject mesh,TQ3MeshEdge edge,TQ3AttributeSet attributeSet)6697 Q3Mesh_SetEdgeAttributeSet(TQ3GeometryObject mesh, TQ3MeshEdge edge, TQ3AttributeSet attributeSet)
6698 {
6699
6700
6701 // Release build checks
6702 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6703
6704
6705
6706 // Debug build checks
6707 #if Q3_DEBUG
6708 if (0) // Further checks on mesh
6709 return(kQ3Failure);
6710
6711 if (0) // Further checks on edge
6712 return(kQ3Failure);
6713
6714 if (0) // Further checks on attributeSet
6715 return(kQ3Failure);
6716 #endif
6717
6718
6719
6720 // Call the bottleneck
6721 E3System_Bottleneck();
6722
6723
6724
6725 // Call our implementation
6726 return(E3Mesh_SetEdgeAttributeSet(mesh, edge, attributeSet));
6727 }
6728
6729
6730
6731
6732
6733 //=============================================================================
6734 // Q3Mesh_GetContourFace : Quesa API entry point.
6735 //-----------------------------------------------------------------------------
6736 TQ3Status
Q3Mesh_GetContourFace(TQ3GeometryObject mesh,TQ3MeshContour contour,TQ3MeshFace * face)6737 Q3Mesh_GetContourFace(TQ3GeometryObject mesh, TQ3MeshContour contour, TQ3MeshFace *face)
6738 {
6739
6740
6741 // Release build checks
6742 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6743 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(face), kQ3Failure);
6744
6745
6746
6747 // Debug build checks
6748 #if Q3_DEBUG
6749 if (0) // Further checks on mesh
6750 return(kQ3Failure);
6751
6752 if (0) // Further checks on contour
6753 return(kQ3Failure);
6754
6755 if (0) // Further checks on face
6756 return(kQ3Failure);
6757 #endif
6758
6759
6760
6761 // Call the bottleneck
6762 E3System_Bottleneck();
6763
6764
6765
6766 // Call our implementation
6767 return(E3Mesh_GetContourFace(mesh, contour, face));
6768 }
6769
6770
6771
6772
6773
6774 //=============================================================================
6775 // Q3Mesh_GetContourNumVertices : Quesa API entry point.
6776 //-----------------------------------------------------------------------------
6777 TQ3Status
Q3Mesh_GetContourNumVertices(TQ3GeometryObject mesh,TQ3MeshContour contour,TQ3Uns32 * numVertices)6778 Q3Mesh_GetContourNumVertices(TQ3GeometryObject mesh, TQ3MeshContour contour, TQ3Uns32 *numVertices)
6779 {
6780
6781
6782 // Release build checks
6783 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6784 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(numVertices), kQ3Failure);
6785
6786
6787
6788 // Debug build checks
6789 #if Q3_DEBUG
6790 if (0) // Further checks on mesh
6791 return(kQ3Failure);
6792
6793 if (0) // Further checks on contour
6794 return(kQ3Failure);
6795
6796 if (0) // Further checks on numVertices
6797 return(kQ3Failure);
6798 #endif
6799
6800
6801
6802 // Call the bottleneck
6803 E3System_Bottleneck();
6804
6805
6806
6807 // Call our implementation
6808 return(E3Mesh_GetContourNumVertices(mesh, contour, numVertices));
6809 }
6810
6811
6812
6813
6814
6815 //=============================================================================
6816 // Q3Mesh_GetCornerAttributeSet : Quesa API entry point.
6817 //-----------------------------------------------------------------------------
6818 TQ3Status
Q3Mesh_GetCornerAttributeSet(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3MeshFace face,TQ3AttributeSet * attributeSet)6819 Q3Mesh_GetCornerAttributeSet(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3MeshFace face, TQ3AttributeSet *attributeSet)
6820 {
6821
6822
6823 // Release build checks
6824 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6825 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
6826
6827
6828
6829 // Debug build checks
6830 #if Q3_DEBUG
6831 if (0) // Further checks on mesh
6832 return(kQ3Failure);
6833
6834 if (0) // Further checks on vertex
6835 return(kQ3Failure);
6836
6837 if (0) // Further checks on face
6838 return(kQ3Failure);
6839
6840 if (0) // Further checks on attributeSet
6841 return(kQ3Failure);
6842 #endif
6843
6844
6845
6846 // Call the bottleneck
6847 E3System_Bottleneck();
6848
6849
6850
6851 // Call our implementation
6852 return(E3Mesh_GetCornerAttributeSet(mesh, vertex, face, attributeSet));
6853 }
6854
6855
6856
6857
6858
6859 //=============================================================================
6860 // Q3Mesh_SetCornerAttributeSet : Quesa API entry point.
6861 //-----------------------------------------------------------------------------
6862 TQ3Status
Q3Mesh_SetCornerAttributeSet(TQ3GeometryObject mesh,TQ3MeshVertex vertex,TQ3MeshFace face,TQ3AttributeSet attributeSet)6863 Q3Mesh_SetCornerAttributeSet(TQ3GeometryObject mesh, TQ3MeshVertex vertex, TQ3MeshFace face, TQ3AttributeSet attributeSet)
6864 {
6865
6866
6867 // Release build checks
6868 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), kQ3Failure);
6869
6870
6871
6872 // Debug build checks
6873 #if Q3_DEBUG
6874 if (0) // Further checks on mesh
6875 return(kQ3Failure);
6876
6877 if (0) // Further checks on vertex
6878 return(kQ3Failure);
6879
6880 if (0) // Further checks on face
6881 return(kQ3Failure);
6882
6883 if (0) // Further checks on attributeSet
6884 return(kQ3Failure);
6885 #endif
6886
6887
6888
6889 // Call the bottleneck
6890 E3System_Bottleneck();
6891
6892
6893
6894 // Call our implementation
6895 return(E3Mesh_SetCornerAttributeSet(mesh, vertex, face, attributeSet));
6896 }
6897
6898
6899
6900
6901
6902 //=============================================================================
6903 // Q3Mesh_FirstMeshComponent : Quesa API entry point.
6904 //-----------------------------------------------------------------------------
6905 TQ3MeshComponent
Q3Mesh_FirstMeshComponent(TQ3GeometryObject mesh,TQ3MeshIterator * iterator)6906 Q3Mesh_FirstMeshComponent(TQ3GeometryObject mesh, TQ3MeshIterator *iterator)
6907 {
6908
6909
6910 // Release build checks
6911 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
6912 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
6913
6914
6915
6916 // Debug build checks
6917 #if Q3_DEBUG
6918 if (0) // Further checks on mesh
6919 return(NULL);
6920
6921 if (0) // Further checks on iterator
6922 return(NULL);
6923 #endif
6924
6925
6926
6927 // Call the bottleneck
6928 E3System_Bottleneck();
6929
6930
6931
6932 // Call our implementation
6933 return(E3Mesh_FirstMeshComponent(mesh, iterator));
6934 }
6935
6936
6937
6938
6939
6940 //=============================================================================
6941 // Q3Mesh_NextMeshComponent : Quesa API entry point.
6942 //-----------------------------------------------------------------------------
6943 TQ3MeshComponent
Q3Mesh_NextMeshComponent(TQ3MeshIterator * iterator)6944 Q3Mesh_NextMeshComponent(TQ3MeshIterator *iterator)
6945 {
6946
6947
6948 // Release build checks
6949 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
6950
6951
6952
6953 // Debug build checks
6954 #if Q3_DEBUG
6955 if (0) // Further checks on iterator
6956 return(NULL);
6957 #endif
6958
6959
6960
6961 // Call the bottleneck
6962 E3System_Bottleneck();
6963
6964
6965
6966 // Call our implementation
6967 return(E3Mesh_NextMeshComponent(iterator));
6968 }
6969
6970
6971
6972
6973
6974 //=============================================================================
6975 // Q3Mesh_FirstComponentVertex : Quesa API entry point.
6976 //-----------------------------------------------------------------------------
6977 TQ3MeshVertex
Q3Mesh_FirstComponentVertex(TQ3MeshComponent component,TQ3MeshIterator * iterator)6978 Q3Mesh_FirstComponentVertex(TQ3MeshComponent component, TQ3MeshIterator *iterator)
6979 {
6980
6981
6982 // Release build checks
6983 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
6984
6985
6986
6987 // Debug build checks
6988 #if Q3_DEBUG
6989 if (0) // Further checks on component
6990 return(NULL);
6991
6992 if (0) // Further checks on iterator
6993 return(NULL);
6994 #endif
6995
6996
6997
6998 // Call the bottleneck
6999 E3System_Bottleneck();
7000
7001
7002
7003 // Call our implementation
7004 return(E3Mesh_FirstComponentVertex(component, iterator));
7005 }
7006
7007
7008
7009
7010
7011 //=============================================================================
7012 // Q3Mesh_NextComponentVertex : Quesa API entry point.
7013 //-----------------------------------------------------------------------------
7014 TQ3MeshVertex
Q3Mesh_NextComponentVertex(TQ3MeshIterator * iterator)7015 Q3Mesh_NextComponentVertex(TQ3MeshIterator *iterator)
7016 {
7017
7018
7019 // Release build checks
7020 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7021
7022
7023
7024 // Debug build checks
7025 #if Q3_DEBUG
7026 if (0) // Further checks on iterator
7027 return(NULL);
7028 #endif
7029
7030
7031
7032 // Call the bottleneck
7033 E3System_Bottleneck();
7034
7035
7036
7037 // Call our implementation
7038 return(E3Mesh_NextComponentVertex(iterator));
7039 }
7040
7041
7042
7043
7044
7045 //=============================================================================
7046 // Q3Mesh_FirstComponentEdge : Quesa API entry point.
7047 //-----------------------------------------------------------------------------
7048 TQ3MeshEdge
Q3Mesh_FirstComponentEdge(TQ3MeshComponent component,TQ3MeshIterator * iterator)7049 Q3Mesh_FirstComponentEdge(TQ3MeshComponent component, TQ3MeshIterator *iterator)
7050 {
7051
7052
7053 // Release build checks
7054 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7055
7056
7057
7058 // Debug build checks
7059 #if Q3_DEBUG
7060 if (0) // Further checks on component
7061 return(NULL);
7062
7063 if (0) // Further checks on iterator
7064 return(NULL);
7065 #endif
7066
7067
7068
7069 // Call the bottleneck
7070 E3System_Bottleneck();
7071
7072
7073
7074 // Call our implementation
7075 return(E3Mesh_FirstComponentEdge(component, iterator));
7076 }
7077
7078
7079
7080
7081
7082 //=============================================================================
7083 // Q3Mesh_NextComponentEdge : Quesa API entry point.
7084 //-----------------------------------------------------------------------------
7085 TQ3MeshEdge
Q3Mesh_NextComponentEdge(TQ3MeshIterator * iterator)7086 Q3Mesh_NextComponentEdge(TQ3MeshIterator *iterator)
7087 {
7088
7089
7090 // Release build checks
7091 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7092
7093
7094
7095 // Debug build checks
7096 #if Q3_DEBUG
7097 if (0) // Further checks on iterator
7098 return(NULL);
7099 #endif
7100
7101
7102
7103 // Call the bottleneck
7104 E3System_Bottleneck();
7105
7106
7107
7108 // Call our implementation
7109 return(E3Mesh_NextComponentEdge(iterator));
7110 }
7111
7112
7113
7114
7115
7116 //=============================================================================
7117 // Q3Mesh_FirstMeshVertex : Quesa API entry point.
7118 //-----------------------------------------------------------------------------
7119 TQ3MeshVertex
Q3Mesh_FirstMeshVertex(TQ3GeometryObject mesh,TQ3MeshIterator * iterator)7120 Q3Mesh_FirstMeshVertex(TQ3GeometryObject mesh, TQ3MeshIterator *iterator)
7121 {
7122
7123
7124 // Release build checks
7125 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
7126 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7127
7128
7129
7130 // Debug build checks
7131 #if Q3_DEBUG
7132 if (0) // Further checks on mesh
7133 return(NULL);
7134
7135 if (0) // Further checks on iterator
7136 return(NULL);
7137 #endif
7138
7139
7140
7141 // Call the bottleneck
7142 E3System_Bottleneck();
7143
7144
7145
7146 // Call our implementation
7147 return(E3Mesh_FirstMeshVertex(mesh, iterator));
7148 }
7149
7150
7151
7152
7153
7154 //=============================================================================
7155 // Q3Mesh_NextMeshVertex : Quesa API entry point.
7156 //-----------------------------------------------------------------------------
7157 TQ3MeshVertex
Q3Mesh_NextMeshVertex(TQ3MeshIterator * iterator)7158 Q3Mesh_NextMeshVertex(TQ3MeshIterator *iterator)
7159 {
7160
7161
7162 // Release build checks
7163 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7164
7165
7166
7167 // Debug build checks
7168 #if Q3_DEBUG
7169 if (0) // Further checks on iterator
7170 return(NULL);
7171 #endif
7172
7173
7174
7175 // Call the bottleneck
7176 E3System_Bottleneck();
7177
7178
7179
7180 // Call our implementation
7181 return(E3Mesh_NextMeshVertex(iterator));
7182 }
7183
7184
7185
7186
7187
7188 //=============================================================================
7189 // Q3Mesh_FirstMeshFace : Quesa API entry point.
7190 //-----------------------------------------------------------------------------
7191 TQ3MeshFace
Q3Mesh_FirstMeshFace(TQ3GeometryObject mesh,TQ3MeshIterator * iterator)7192 Q3Mesh_FirstMeshFace(TQ3GeometryObject mesh, TQ3MeshIterator *iterator)
7193 {
7194
7195
7196 // Release build checks
7197 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
7198 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7199
7200
7201
7202 // Debug build checks
7203 #if Q3_DEBUG
7204 if (0) // Further checks on mesh
7205 return(NULL);
7206
7207 if (0) // Further checks on iterator
7208 return(NULL);
7209 #endif
7210
7211
7212
7213 // Call the bottleneck
7214 E3System_Bottleneck();
7215
7216
7217
7218 // Call our implementation
7219 return(E3Mesh_FirstMeshFace(mesh, iterator));
7220 }
7221
7222
7223
7224
7225
7226 //=============================================================================
7227 // Q3Mesh_NextMeshFace : Quesa API entry point.
7228 //-----------------------------------------------------------------------------
7229 TQ3MeshFace
Q3Mesh_NextMeshFace(TQ3MeshIterator * iterator)7230 Q3Mesh_NextMeshFace(TQ3MeshIterator *iterator)
7231 {
7232
7233
7234 // Release build checks
7235 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7236
7237
7238
7239 // Debug build checks
7240 #if Q3_DEBUG
7241 if (0) // Further checks on iterator
7242 return(NULL);
7243 #endif
7244
7245
7246
7247 // Call the bottleneck
7248 E3System_Bottleneck();
7249
7250
7251
7252 // Call our implementation
7253 return(E3Mesh_NextMeshFace(iterator));
7254 }
7255
7256
7257
7258
7259
7260 //=============================================================================
7261 // Q3Mesh_FirstMeshEdge : Quesa API entry point.
7262 //-----------------------------------------------------------------------------
7263 TQ3MeshEdge
Q3Mesh_FirstMeshEdge(TQ3GeometryObject mesh,TQ3MeshIterator * iterator)7264 Q3Mesh_FirstMeshEdge(TQ3GeometryObject mesh, TQ3MeshIterator *iterator)
7265 {
7266
7267
7268 // Release build checks
7269 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( mesh ), NULL);
7270 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7271
7272
7273
7274 // Debug build checks
7275 #if Q3_DEBUG
7276 if (0) // Further checks on mesh
7277 return(NULL);
7278
7279 if (0) // Further checks on iterator
7280 return(NULL);
7281 #endif
7282
7283
7284
7285 // Call the bottleneck
7286 E3System_Bottleneck();
7287
7288
7289
7290 // Call our implementation
7291 return(E3Mesh_FirstMeshEdge(mesh, iterator));
7292 }
7293
7294
7295
7296
7297
7298 //=============================================================================
7299 // Q3Mesh_NextMeshEdge : Quesa API entry point.
7300 //-----------------------------------------------------------------------------
7301 TQ3MeshEdge
Q3Mesh_NextMeshEdge(TQ3MeshIterator * iterator)7302 Q3Mesh_NextMeshEdge(TQ3MeshIterator *iterator)
7303 {
7304
7305
7306 // Release build checks
7307 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7308
7309
7310
7311 // Debug build checks
7312 #if Q3_DEBUG
7313 if (0) // Further checks on iterator
7314 return(NULL);
7315 #endif
7316
7317
7318
7319 // Call the bottleneck
7320 E3System_Bottleneck();
7321
7322
7323
7324 // Call our implementation
7325 return(E3Mesh_NextMeshEdge(iterator));
7326 }
7327
7328
7329
7330
7331
7332 //=============================================================================
7333 // Q3Mesh_FirstVertexEdge : Quesa API entry point.
7334 //-----------------------------------------------------------------------------
7335 TQ3MeshEdge
Q3Mesh_FirstVertexEdge(TQ3MeshVertex vertex,TQ3MeshIterator * iterator)7336 Q3Mesh_FirstVertexEdge(TQ3MeshVertex vertex, TQ3MeshIterator *iterator)
7337 {
7338
7339
7340 // Release build checks
7341 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7342
7343
7344
7345 // Debug build checks
7346 #if Q3_DEBUG
7347 if (0) // Further checks on vertex
7348 return(NULL);
7349
7350 if (0) // Further checks on iterator
7351 return(NULL);
7352 #endif
7353
7354
7355
7356 // Call the bottleneck
7357 E3System_Bottleneck();
7358
7359
7360
7361 // Call our implementation
7362 return(E3Mesh_FirstVertexEdge(vertex, iterator));
7363 }
7364
7365
7366
7367
7368
7369 //=============================================================================
7370 // Q3Mesh_NextVertexEdge : Quesa API entry point.
7371 //-----------------------------------------------------------------------------
7372 TQ3MeshEdge
Q3Mesh_NextVertexEdge(TQ3MeshIterator * iterator)7373 Q3Mesh_NextVertexEdge(TQ3MeshIterator *iterator)
7374 {
7375
7376
7377 // Release build checks
7378 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7379
7380
7381
7382 // Debug build checks
7383 #if Q3_DEBUG
7384 if (0) // Further checks on iterator
7385 return(NULL);
7386 #endif
7387
7388
7389
7390 // Call the bottleneck
7391 E3System_Bottleneck();
7392
7393
7394
7395 // Call our implementation
7396 return(E3Mesh_NextVertexEdge(iterator));
7397 }
7398
7399
7400
7401
7402
7403 //=============================================================================
7404 // Q3Mesh_FirstVertexVertex : Quesa API entry point.
7405 //-----------------------------------------------------------------------------
7406 TQ3MeshVertex
Q3Mesh_FirstVertexVertex(TQ3MeshVertex vertex,TQ3MeshIterator * iterator)7407 Q3Mesh_FirstVertexVertex(TQ3MeshVertex vertex, TQ3MeshIterator *iterator)
7408 {
7409
7410
7411 // Release build checks
7412 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7413
7414
7415
7416 // Debug build checks
7417 #if Q3_DEBUG
7418 if (0) // Further checks on vertex
7419 return(NULL);
7420
7421 if (0) // Further checks on iterator
7422 return(NULL);
7423 #endif
7424
7425
7426
7427 // Call the bottleneck
7428 E3System_Bottleneck();
7429
7430
7431
7432 // Call our implementation
7433 return(E3Mesh_FirstVertexVertex(vertex, iterator));
7434 }
7435
7436
7437
7438
7439
7440 //=============================================================================
7441 // Q3Mesh_NextVertexVertex : Quesa API entry point.
7442 //-----------------------------------------------------------------------------
7443 TQ3MeshVertex
Q3Mesh_NextVertexVertex(TQ3MeshIterator * iterator)7444 Q3Mesh_NextVertexVertex(TQ3MeshIterator *iterator)
7445 {
7446
7447
7448 // Release build checks
7449 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7450
7451
7452
7453 // Debug build checks
7454 #if Q3_DEBUG
7455 if (0) // Further checks on iterator
7456 return(NULL);
7457 #endif
7458
7459
7460
7461 // Call the bottleneck
7462 E3System_Bottleneck();
7463
7464
7465
7466 // Call our implementation
7467 return(E3Mesh_NextVertexVertex(iterator));
7468 }
7469
7470
7471
7472
7473
7474 //=============================================================================
7475 // Q3Mesh_FirstVertexFace : Quesa API entry point.
7476 //-----------------------------------------------------------------------------
7477 TQ3MeshFace
Q3Mesh_FirstVertexFace(TQ3MeshVertex vertex,TQ3MeshIterator * iterator)7478 Q3Mesh_FirstVertexFace(TQ3MeshVertex vertex, TQ3MeshIterator *iterator)
7479 {
7480
7481
7482 // Release build checks
7483 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7484
7485
7486
7487 // Debug build checks
7488 #if Q3_DEBUG
7489 if (0) // Further checks on vertex
7490 return(NULL);
7491
7492 if (0) // Further checks on iterator
7493 return(NULL);
7494 #endif
7495
7496
7497
7498 // Call the bottleneck
7499 E3System_Bottleneck();
7500
7501
7502
7503 // Call our implementation
7504 return(E3Mesh_FirstVertexFace(vertex, iterator));
7505 }
7506
7507
7508
7509
7510
7511 //=============================================================================
7512 // Q3Mesh_NextVertexFace : Quesa API entry point.
7513 //-----------------------------------------------------------------------------
7514 TQ3MeshFace
Q3Mesh_NextVertexFace(TQ3MeshIterator * iterator)7515 Q3Mesh_NextVertexFace(TQ3MeshIterator *iterator)
7516 {
7517
7518
7519 // Release build checks
7520 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7521
7522
7523
7524 // Debug build checks
7525 #if Q3_DEBUG
7526 if (0) // Further checks on iterator
7527 return(NULL);
7528 #endif
7529
7530
7531
7532 // Call the bottleneck
7533 E3System_Bottleneck();
7534
7535
7536
7537 // Call our implementation
7538 return(E3Mesh_NextVertexFace(iterator));
7539 }
7540
7541
7542
7543
7544
7545 //=============================================================================
7546 // Q3Mesh_FirstFaceEdge : Quesa API entry point.
7547 //-----------------------------------------------------------------------------
7548 TQ3MeshEdge
Q3Mesh_FirstFaceEdge(TQ3MeshFace face,TQ3MeshIterator * iterator)7549 Q3Mesh_FirstFaceEdge(TQ3MeshFace face, TQ3MeshIterator *iterator)
7550 {
7551
7552
7553 // Release build checks
7554 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7555
7556
7557
7558 // Debug build checks
7559 #if Q3_DEBUG
7560 if (0) // Further checks on face
7561 return(NULL);
7562
7563 if (0) // Further checks on iterator
7564 return(NULL);
7565 #endif
7566
7567
7568
7569 // Call the bottleneck
7570 E3System_Bottleneck();
7571
7572
7573
7574 // Call our implementation
7575 return(E3Mesh_FirstFaceEdge(face, iterator));
7576 }
7577
7578
7579
7580
7581
7582 //=============================================================================
7583 // Q3Mesh_NextFaceEdge : Quesa API entry point.
7584 //-----------------------------------------------------------------------------
7585 TQ3MeshEdge
Q3Mesh_NextFaceEdge(TQ3MeshIterator * iterator)7586 Q3Mesh_NextFaceEdge(TQ3MeshIterator *iterator)
7587 {
7588
7589
7590 // Release build checks
7591 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7592
7593
7594
7595 // Debug build checks
7596 #if Q3_DEBUG
7597 if (0) // Further checks on iterator
7598 return(NULL);
7599 #endif
7600
7601
7602
7603 // Call the bottleneck
7604 E3System_Bottleneck();
7605
7606
7607
7608 // Call our implementation
7609 return(E3Mesh_NextFaceEdge(iterator));
7610 }
7611
7612
7613
7614
7615
7616 //=============================================================================
7617 // Q3Mesh_FirstFaceVertex : Quesa API entry point.
7618 //-----------------------------------------------------------------------------
7619 TQ3MeshVertex
Q3Mesh_FirstFaceVertex(TQ3MeshFace face,TQ3MeshIterator * iterator)7620 Q3Mesh_FirstFaceVertex(TQ3MeshFace face, TQ3MeshIterator *iterator)
7621 {
7622
7623
7624 // Release build checks
7625 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7626
7627
7628
7629 // Debug build checks
7630 #if Q3_DEBUG
7631 if (0) // Further checks on face
7632 return(NULL);
7633
7634 if (0) // Further checks on iterator
7635 return(NULL);
7636 #endif
7637
7638
7639
7640 // Call the bottleneck
7641 E3System_Bottleneck();
7642
7643
7644
7645 // Call our implementation
7646 return(E3Mesh_FirstFaceVertex(face, iterator));
7647 }
7648
7649
7650
7651
7652
7653 //=============================================================================
7654 // Q3Mesh_NextFaceVertex : Quesa API entry point.
7655 //-----------------------------------------------------------------------------
7656 TQ3MeshVertex
Q3Mesh_NextFaceVertex(TQ3MeshIterator * iterator)7657 Q3Mesh_NextFaceVertex(TQ3MeshIterator *iterator)
7658 {
7659
7660
7661 // Release build checks
7662 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7663
7664
7665
7666 // Debug build checks
7667 #if Q3_DEBUG
7668 if (0) // Further checks on iterator
7669 return(NULL);
7670 #endif
7671
7672
7673
7674 // Call the bottleneck
7675 E3System_Bottleneck();
7676
7677
7678
7679 // Call our implementation
7680 return(E3Mesh_NextFaceVertex(iterator));
7681 }
7682
7683
7684
7685
7686
7687 //=============================================================================
7688 // Q3Mesh_FirstFaceFace : Quesa API entry point.
7689 //-----------------------------------------------------------------------------
7690 TQ3MeshFace
Q3Mesh_FirstFaceFace(TQ3MeshFace face,TQ3MeshIterator * iterator)7691 Q3Mesh_FirstFaceFace(TQ3MeshFace face, TQ3MeshIterator *iterator)
7692 {
7693
7694
7695 // Release build checks
7696 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7697
7698
7699
7700 // Debug build checks
7701 #if Q3_DEBUG
7702 if (0) // Further checks on face
7703 return(NULL);
7704
7705 if (0) // Further checks on iterator
7706 return(NULL);
7707 #endif
7708
7709
7710
7711 // Call the bottleneck
7712 E3System_Bottleneck();
7713
7714
7715
7716 // Call our implementation
7717 return(E3Mesh_FirstFaceFace(face, iterator));
7718 }
7719
7720
7721
7722
7723
7724 //=============================================================================
7725 // Q3Mesh_NextFaceFace : Quesa API entry point.
7726 //-----------------------------------------------------------------------------
7727 TQ3MeshFace
Q3Mesh_NextFaceFace(TQ3MeshIterator * iterator)7728 Q3Mesh_NextFaceFace(TQ3MeshIterator *iterator)
7729 {
7730
7731
7732 // Release build checks
7733 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7734
7735
7736
7737 // Debug build checks
7738 #if Q3_DEBUG
7739 if (0) // Further checks on iterator
7740 return(NULL);
7741 #endif
7742
7743
7744
7745 // Call the bottleneck
7746 E3System_Bottleneck();
7747
7748
7749
7750 // Call our implementation
7751 return(E3Mesh_NextFaceFace(iterator));
7752 }
7753
7754
7755
7756
7757
7758 //=============================================================================
7759 // Q3Mesh_FirstFaceContour : Quesa API entry point.
7760 //-----------------------------------------------------------------------------
7761 TQ3MeshContour
Q3Mesh_FirstFaceContour(TQ3MeshFace face,TQ3MeshIterator * iterator)7762 Q3Mesh_FirstFaceContour(TQ3MeshFace face, TQ3MeshIterator *iterator)
7763 {
7764
7765
7766 // Release build checks
7767 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7768
7769
7770
7771 // Debug build checks
7772 #if Q3_DEBUG
7773 if (0) // Further checks on face
7774 return(NULL);
7775
7776 if (0) // Further checks on iterator
7777 return(NULL);
7778 #endif
7779
7780
7781
7782 // Call the bottleneck
7783 E3System_Bottleneck();
7784
7785
7786
7787 // Call our implementation
7788 return(E3Mesh_FirstFaceContour(face, iterator));
7789 }
7790
7791
7792
7793
7794
7795 //=============================================================================
7796 // Q3Mesh_NextFaceContour : Quesa API entry point.
7797 //-----------------------------------------------------------------------------
7798 TQ3MeshContour
Q3Mesh_NextFaceContour(TQ3MeshIterator * iterator)7799 Q3Mesh_NextFaceContour(TQ3MeshIterator *iterator)
7800 {
7801
7802
7803 // Release build checks
7804 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7805
7806
7807
7808 // Debug build checks
7809 #if Q3_DEBUG
7810 if (0) // Further checks on iterator
7811 return(NULL);
7812 #endif
7813
7814
7815
7816 // Call the bottleneck
7817 E3System_Bottleneck();
7818
7819
7820
7821 // Call our implementation
7822 return(E3Mesh_NextFaceContour(iterator));
7823 }
7824
7825
7826
7827
7828
7829 //=============================================================================
7830 // Q3Mesh_FirstContourEdge : Quesa API entry point.
7831 //-----------------------------------------------------------------------------
7832 TQ3MeshEdge
Q3Mesh_FirstContourEdge(TQ3MeshContour contour,TQ3MeshIterator * iterator)7833 Q3Mesh_FirstContourEdge(TQ3MeshContour contour, TQ3MeshIterator *iterator)
7834 {
7835
7836
7837 // Release build checks
7838 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7839
7840
7841
7842 // Debug build checks
7843 #if Q3_DEBUG
7844 if (0) // Further checks on contour
7845 return(NULL);
7846
7847 if (0) // Further checks on iterator
7848 return(NULL);
7849 #endif
7850
7851
7852
7853 // Call the bottleneck
7854 E3System_Bottleneck();
7855
7856
7857
7858 // Call our implementation
7859 return(E3Mesh_FirstContourEdge(contour, iterator));
7860 }
7861
7862
7863
7864
7865
7866 //=============================================================================
7867 // Q3Mesh_NextContourEdge : Quesa API entry point.
7868 //-----------------------------------------------------------------------------
7869 TQ3MeshEdge
Q3Mesh_NextContourEdge(TQ3MeshIterator * iterator)7870 Q3Mesh_NextContourEdge(TQ3MeshIterator *iterator)
7871 {
7872
7873
7874 // Release build checks
7875 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7876
7877
7878
7879 // Debug build checks
7880 #if Q3_DEBUG
7881 if (0) // Further checks on iterator
7882 return(NULL);
7883 #endif
7884
7885
7886
7887 // Call the bottleneck
7888 E3System_Bottleneck();
7889
7890
7891
7892 // Call our implementation
7893 return(E3Mesh_NextContourEdge(iterator));
7894 }
7895
7896
7897
7898
7899
7900 //=============================================================================
7901 // Q3Mesh_FirstContourVertex : Quesa API entry point.
7902 //-----------------------------------------------------------------------------
7903 TQ3MeshVertex
Q3Mesh_FirstContourVertex(TQ3MeshContour contour,TQ3MeshIterator * iterator)7904 Q3Mesh_FirstContourVertex(TQ3MeshContour contour, TQ3MeshIterator *iterator)
7905 {
7906
7907
7908 // Release build checks
7909 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7910
7911
7912
7913 // Debug build checks
7914 #if Q3_DEBUG
7915 if (0) // Further checks on contour
7916 return(NULL);
7917
7918 if (0) // Further checks on iterator
7919 return(NULL);
7920 #endif
7921
7922
7923
7924 // Call the bottleneck
7925 E3System_Bottleneck();
7926
7927
7928
7929 // Call our implementation
7930 return(E3Mesh_FirstContourVertex(contour, iterator));
7931 }
7932
7933
7934
7935
7936
7937 //=============================================================================
7938 // Q3Mesh_NextContourVertex : Quesa API entry point.
7939 //-----------------------------------------------------------------------------
7940 TQ3MeshVertex
Q3Mesh_NextContourVertex(TQ3MeshIterator * iterator)7941 Q3Mesh_NextContourVertex(TQ3MeshIterator *iterator)
7942 {
7943
7944
7945 // Release build checks
7946 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7947
7948
7949
7950 // Debug build checks
7951 #if Q3_DEBUG
7952 if (0) // Further checks on iterator
7953 return(NULL);
7954 #endif
7955
7956
7957
7958 // Call the bottleneck
7959 E3System_Bottleneck();
7960
7961
7962
7963 // Call our implementation
7964 return(E3Mesh_NextContourVertex(iterator));
7965 }
7966
7967
7968
7969
7970
7971 //=============================================================================
7972 // Q3Mesh_FirstContourFace : Quesa API entry point.
7973 //-----------------------------------------------------------------------------
7974 TQ3MeshFace
Q3Mesh_FirstContourFace(TQ3MeshContour contour,TQ3MeshIterator * iterator)7975 Q3Mesh_FirstContourFace(TQ3MeshContour contour, TQ3MeshIterator *iterator)
7976 {
7977
7978
7979 // Release build checks
7980 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
7981
7982
7983
7984 // Debug build checks
7985 #if Q3_DEBUG
7986 if (0) // Further checks on contour
7987 return(NULL);
7988
7989 if (0) // Further checks on iterator
7990 return(NULL);
7991 #endif
7992
7993
7994
7995 // Call the bottleneck
7996 E3System_Bottleneck();
7997
7998
7999
8000 // Call our implementation
8001 return(E3Mesh_FirstContourFace(contour, iterator));
8002 }
8003
8004
8005
8006
8007
8008 //=============================================================================
8009 // Q3Mesh_NextContourFace : Quesa API entry point.
8010 //-----------------------------------------------------------------------------
8011 TQ3MeshFace
Q3Mesh_NextContourFace(TQ3MeshIterator * iterator)8012 Q3Mesh_NextContourFace(TQ3MeshIterator *iterator)
8013 {
8014
8015
8016 // Release build checks
8017 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(iterator), NULL);
8018
8019
8020
8021 // Debug build checks
8022 #if Q3_DEBUG
8023 if (0) // Further checks on iterator
8024 return(NULL);
8025 #endif
8026
8027
8028
8029 // Call the bottleneck
8030 E3System_Bottleneck();
8031
8032
8033
8034 // Call our implementation
8035 return(E3Mesh_NextContourFace(iterator));
8036 }
8037
8038
8039
8040
8041
8042 //=============================================================================
8043 // Q3NURBCurve_New : Quesa API entry point.
8044 //-----------------------------------------------------------------------------
8045 TQ3GeometryObject
Q3NURBCurve_New(const TQ3NURBCurveData * curveData)8046 Q3NURBCurve_New(const TQ3NURBCurveData *curveData)
8047 {
8048
8049
8050 // Release build checks
8051 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(curveData), NULL);
8052
8053
8054
8055 // Debug build checks
8056 #if Q3_DEBUG
8057 // Further checks on curveData
8058 if (curveData->order > kQ3NURBCurveMaxOrder)
8059 return(NULL);
8060 #endif
8061
8062
8063
8064 // Call the bottleneck
8065 E3System_Bottleneck();
8066
8067
8068
8069 // Call our implementation
8070 return(E3NURBCurve_New(curveData));
8071 }
8072
8073
8074
8075
8076
8077 //=============================================================================
8078 // Q3NURBCurve_Submit : Quesa API entry point.
8079 //-----------------------------------------------------------------------------
8080 TQ3Status
Q3NURBCurve_Submit(const TQ3NURBCurveData * curveData,TQ3ViewObject view)8081 Q3NURBCurve_Submit(const TQ3NURBCurveData *curveData, TQ3ViewObject view)
8082 {
8083
8084
8085 // Release build checks
8086 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(curveData), kQ3Failure);
8087 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
8088
8089
8090
8091 // Debug build checks
8092 #if Q3_DEBUG
8093 // Further checks on curveData
8094 if (curveData->order > kQ3NURBCurveMaxOrder)
8095 return(kQ3Failure);
8096
8097 if (0) // Further checks on view
8098 return(kQ3Failure);
8099 #endif
8100
8101
8102
8103 // Call the bottleneck
8104 E3System_Bottleneck();
8105
8106
8107
8108 // Call our implementation
8109 return(E3NURBCurve_Submit(curveData, view));
8110 }
8111
8112
8113
8114
8115
8116 //=============================================================================
8117 // Q3NURBCurve_SetData : Quesa API entry point.
8118 //-----------------------------------------------------------------------------
8119 TQ3Status
Q3NURBCurve_SetData(TQ3GeometryObject curve,const TQ3NURBCurveData * nurbCurveData)8120 Q3NURBCurve_SetData(TQ3GeometryObject curve, const TQ3NURBCurveData *nurbCurveData)
8121 {
8122
8123
8124 // Release build checks
8125 Q3_REQUIRE_OR_RESULT( E3NURBCurve_IsOfMyClass ( curve ), kQ3Failure);
8126 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbCurveData), kQ3Failure);
8127
8128
8129
8130 // Debug build checks
8131 #if Q3_DEBUG
8132 if (0) // Further checks on curve
8133 return(kQ3Failure);
8134
8135 // Further checks on nurbCurveData
8136 if (nurbCurveData->order > kQ3NURBCurveMaxOrder)
8137 return(kQ3Failure);
8138 #endif
8139
8140
8141
8142 // Call the bottleneck
8143 E3System_Bottleneck();
8144
8145
8146
8147 // Call our implementation
8148 return(E3NURBCurve_SetData(curve, nurbCurveData));
8149 }
8150
8151
8152
8153
8154
8155 //=============================================================================
8156 // Q3NURBCurve_GetData : Quesa API entry point.
8157 //-----------------------------------------------------------------------------
8158 TQ3Status
Q3NURBCurve_GetData(TQ3GeometryObject curve,TQ3NURBCurveData * nurbCurveData)8159 Q3NURBCurve_GetData(TQ3GeometryObject curve, TQ3NURBCurveData *nurbCurveData)
8160 {
8161
8162
8163 // Release build checks
8164 Q3_REQUIRE_OR_RESULT( E3NURBCurve_IsOfMyClass ( curve ), kQ3Failure);
8165 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbCurveData), kQ3Failure);
8166
8167
8168
8169 // Debug build checks
8170 #if Q3_DEBUG
8171 if (0) // Further checks on curve
8172 return(kQ3Failure);
8173
8174 if (0) // Further checks on nurbCurveData
8175 return(kQ3Failure);
8176 #endif
8177
8178
8179
8180 // Call the bottleneck
8181 E3System_Bottleneck();
8182
8183
8184
8185 // Call our implementation
8186 return(E3NURBCurve_GetData(curve, nurbCurveData));
8187 }
8188
8189
8190
8191
8192
8193 //=============================================================================
8194 // Q3NURBCurve_EmptyData : Quesa API entry point.
8195 //-----------------------------------------------------------------------------
8196 TQ3Status
Q3NURBCurve_EmptyData(TQ3NURBCurveData * nurbCurveData)8197 Q3NURBCurve_EmptyData(TQ3NURBCurveData *nurbCurveData)
8198 {
8199
8200
8201 // Release build checks
8202 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbCurveData), kQ3Failure);
8203
8204
8205
8206 // Debug build checks
8207 #if Q3_DEBUG
8208 if (0) // Further checks on nurbCurveData
8209 return(kQ3Failure);
8210 #endif
8211
8212
8213
8214 // Call the bottleneck
8215 E3System_Bottleneck();
8216
8217
8218
8219 // Call our implementation
8220 return(E3NURBCurve_EmptyData(nurbCurveData));
8221 }
8222
8223
8224
8225
8226
8227 //=============================================================================
8228 // Q3NURBCurve_SetControlPoint : Quesa API entry point.
8229 //-----------------------------------------------------------------------------
8230 TQ3Status
Q3NURBCurve_SetControlPoint(TQ3GeometryObject curve,TQ3Uns32 pointIndex,const TQ3RationalPoint4D * point4D)8231 Q3NURBCurve_SetControlPoint(TQ3GeometryObject curve, TQ3Uns32 pointIndex, const TQ3RationalPoint4D *point4D)
8232 {
8233
8234
8235 // Release build checks
8236 Q3_REQUIRE_OR_RESULT( E3NURBCurve_IsOfMyClass ( curve ), kQ3Failure);
8237 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point4D), kQ3Failure);
8238
8239
8240
8241 // Debug build checks
8242 #if Q3_DEBUG
8243 if (0) // Further checks on curve
8244 return(kQ3Failure);
8245
8246 TQ3Uns32 numPoints ;
8247 E3NURBCurve_GetNumPoints ( curve , &numPoints ) ;
8248 // Further checks on pointIndex
8249 if ( pointIndex < 0 || pointIndex >= numPoints )
8250 return kQ3Failure ;
8251
8252 if (0) // Further checks on point4D
8253 return(kQ3Failure);
8254 #endif
8255
8256
8257
8258 // Call the bottleneck
8259 E3System_Bottleneck();
8260
8261
8262
8263 // Call our implementation
8264 return(E3NURBCurve_SetControlPoint(curve, pointIndex, point4D));
8265 }
8266
8267
8268
8269
8270
8271 //=============================================================================
8272 // Q3NURBCurve_GetControlPoint : Quesa API entry point.
8273 //-----------------------------------------------------------------------------
8274 TQ3Status
Q3NURBCurve_GetControlPoint(TQ3GeometryObject curve,TQ3Uns32 pointIndex,TQ3RationalPoint4D * point4D)8275 Q3NURBCurve_GetControlPoint(TQ3GeometryObject curve, TQ3Uns32 pointIndex, TQ3RationalPoint4D *point4D)
8276 {
8277
8278
8279 // Release build checks
8280 Q3_REQUIRE_OR_RESULT( E3NURBCurve_IsOfMyClass ( curve ), kQ3Failure);
8281 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point4D), kQ3Failure);
8282
8283
8284
8285 // Debug build checks
8286 #if Q3_DEBUG
8287 if (0) // Further checks on curve
8288 return(kQ3Failure);
8289
8290 TQ3Uns32 numPoints ;
8291 E3NURBCurve_GetNumPoints ( curve , &numPoints ) ;
8292 // Further checks on pointIndex
8293 if ( pointIndex < 0 || pointIndex >= numPoints )
8294 return kQ3Failure ;
8295
8296 if (0) // Further checks on point4D
8297 return(kQ3Failure);
8298 #endif
8299
8300
8301
8302 // Call the bottleneck
8303 E3System_Bottleneck();
8304
8305
8306
8307 // Call our implementation
8308 return(E3NURBCurve_GetControlPoint(curve, pointIndex, point4D));
8309 }
8310
8311
8312
8313
8314
8315 //=============================================================================
8316 // Q3NURBCurve_SetKnot : Quesa API entry point.
8317 //-----------------------------------------------------------------------------
8318 TQ3Status
Q3NURBCurve_SetKnot(TQ3GeometryObject curve,TQ3Uns32 knotIndex,float knotValue)8319 Q3NURBCurve_SetKnot(TQ3GeometryObject curve, TQ3Uns32 knotIndex, float knotValue)
8320 {
8321 // Release build checks
8322 Q3_REQUIRE_OR_RESULT( E3NURBCurve_IsOfMyClass ( curve ), kQ3Failure);
8323
8324
8325
8326 // Debug build checks
8327 #if Q3_DEBUG
8328 TQ3NURBCurveData* instanceData = (TQ3NURBCurveData*) curve->FindLeafInstanceData () ;
8329
8330 if (0) // Further checks on curve
8331 return(kQ3Failure);
8332
8333 // Further checks on knotIndex
8334 if (knotIndex < 0
8335 ||
8336 knotIndex > instanceData->numPoints +
8337 instanceData->order - 1)
8338 return(kQ3Failure);
8339
8340 // Further checks on knotValue
8341 if (knotIndex > 0
8342 &&
8343 knotValue < instanceData->knots[knotIndex - 1])
8344 return(kQ3Failure);
8345
8346 if (knotIndex < instanceData->numPoints + instanceData->order - 1
8347 &&
8348 knotValue > instanceData->knots[knotIndex + 1])
8349 return(kQ3Failure);
8350 #endif
8351
8352
8353
8354 // Call the bottleneck
8355 E3System_Bottleneck();
8356
8357
8358
8359 // Call our implementation
8360 return(E3NURBCurve_SetKnot(curve, knotIndex, knotValue));
8361 }
8362
8363
8364
8365
8366
8367 //=============================================================================
8368 // Q3NURBCurve_GetKnot : Quesa API entry point.
8369 //-----------------------------------------------------------------------------
8370 TQ3Status
Q3NURBCurve_GetKnot(TQ3GeometryObject curve,TQ3Uns32 knotIndex,float * knotValue)8371 Q3NURBCurve_GetKnot(TQ3GeometryObject curve, TQ3Uns32 knotIndex, float *knotValue)
8372 {
8373 // Release build checks
8374 Q3_REQUIRE_OR_RESULT( E3NURBCurve_IsOfMyClass ( curve ), kQ3Failure);
8375 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(knotValue), kQ3Failure);
8376
8377
8378
8379 // Debug build checks
8380 #if Q3_DEBUG
8381 TQ3NURBCurveData* instanceData = (TQ3NURBCurveData *) curve->FindLeafInstanceData () ;
8382
8383 if (0) // Further checks on curve
8384 return(kQ3Failure);
8385
8386 // Further checks on knotIndex
8387 if (knotIndex < 0
8388 ||
8389 knotIndex > instanceData->numPoints + instanceData->order - 1)
8390 return(kQ3Failure);
8391
8392 if (0) // Further checks on knotValue
8393 return(kQ3Failure);
8394 #endif
8395
8396
8397
8398 // Call the bottleneck
8399 E3System_Bottleneck();
8400
8401
8402
8403 // Call our implementation
8404 return(E3NURBCurve_GetKnot(curve, knotIndex, knotValue));
8405 }
8406
8407
8408
8409
8410
8411 //=============================================================================
8412 // Q3NURBPatch_New : Quesa API entry point.
8413 //-----------------------------------------------------------------------------
8414 TQ3GeometryObject
Q3NURBPatch_New(const TQ3NURBPatchData * nurbPatchData)8415 Q3NURBPatch_New(const TQ3NURBPatchData *nurbPatchData)
8416 {
8417
8418
8419 // Release build checks
8420 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbPatchData), NULL);
8421
8422
8423
8424 // Debug build checks
8425 #if Q3_DEBUG
8426 // Further checks on nurbPatchData
8427 if (nurbPatchData->uOrder > kQ3NURBPatchMaxOrder || nurbPatchData->vOrder > kQ3NURBPatchMaxOrder)
8428 return(NULL);
8429 #endif
8430
8431
8432
8433 // Call the bottleneck
8434 E3System_Bottleneck();
8435
8436
8437
8438 // Call our implementation
8439 return(E3NURBPatch_New(nurbPatchData));
8440 }
8441
8442
8443
8444
8445
8446 //=============================================================================
8447 // Q3NURBPatch_Submit : Quesa API entry point.
8448 //-----------------------------------------------------------------------------
8449 TQ3Status
Q3NURBPatch_Submit(const TQ3NURBPatchData * nurbPatchData,TQ3ViewObject view)8450 Q3NURBPatch_Submit(const TQ3NURBPatchData *nurbPatchData, TQ3ViewObject view)
8451 {
8452
8453
8454 // Release build checks
8455 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbPatchData), kQ3Failure);
8456 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
8457
8458
8459
8460 // Debug build checks
8461 #if Q3_DEBUG
8462 // Further checks on nurbPatchData
8463 if (nurbPatchData->uOrder > kQ3NURBPatchMaxOrder || nurbPatchData->vOrder > kQ3NURBPatchMaxOrder)
8464 return(kQ3Failure);
8465
8466 if (0) // Further checks on view
8467 return(kQ3Failure);
8468 #endif
8469
8470
8471
8472 // Call the bottleneck
8473 E3System_Bottleneck();
8474
8475
8476
8477 // Call our implementation
8478 return(E3NURBPatch_Submit(nurbPatchData, view));
8479 }
8480
8481
8482
8483
8484
8485 //=============================================================================
8486 // Q3NURBPatch_SetData : Quesa API entry point.
8487 //-----------------------------------------------------------------------------
8488 TQ3Status
Q3NURBPatch_SetData(TQ3GeometryObject nurbPatch,const TQ3NURBPatchData * nurbPatchData)8489 Q3NURBPatch_SetData(TQ3GeometryObject nurbPatch, const TQ3NURBPatchData *nurbPatchData)
8490 {
8491
8492
8493 // Release build checks
8494 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8495 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbPatchData), kQ3Failure);
8496
8497
8498
8499 // Debug build checks
8500 #if Q3_DEBUG
8501 if (0) // Further checks on nurbPatch
8502 return(kQ3Failure);
8503
8504 // Further checks on nurbPatchData
8505 if (nurbPatchData->uOrder > kQ3NURBPatchMaxOrder || nurbPatchData->vOrder > kQ3NURBPatchMaxOrder)
8506 return(kQ3Failure);
8507 #endif
8508
8509
8510
8511 // Call the bottleneck
8512 E3System_Bottleneck();
8513
8514
8515
8516 // Call our implementation
8517 return(E3NURBPatch_SetData(nurbPatch, nurbPatchData));
8518 }
8519
8520
8521
8522
8523
8524 //=============================================================================
8525 // Q3NURBPatch_GetData : Quesa API entry point.
8526 //-----------------------------------------------------------------------------
8527 TQ3Status
Q3NURBPatch_GetData(TQ3GeometryObject nurbPatch,TQ3NURBPatchData * nurbPatchData)8528 Q3NURBPatch_GetData(TQ3GeometryObject nurbPatch, TQ3NURBPatchData *nurbPatchData)
8529 {
8530
8531
8532 // Release build checks
8533 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8534 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbPatchData), kQ3Failure);
8535
8536
8537
8538 // Debug build checks
8539 #if Q3_DEBUG
8540 if (0) // Further checks on nurbPatch
8541 return(kQ3Failure);
8542
8543 if (0) // Further checks on nurbPatchData
8544 return(kQ3Failure);
8545 #endif
8546
8547
8548
8549 // Call the bottleneck
8550 E3System_Bottleneck();
8551
8552
8553
8554 // Call our implementation
8555 return(E3NURBPatch_GetData(nurbPatch, nurbPatchData));
8556 }
8557
8558
8559
8560
8561
8562 //=============================================================================
8563 // Q3NURBPatch_SetControlPoint : Quesa API entry point.
8564 //-----------------------------------------------------------------------------
8565 TQ3Status
Q3NURBPatch_SetControlPoint(TQ3GeometryObject nurbPatch,TQ3Uns32 rowIndex,TQ3Uns32 columnIndex,const TQ3RationalPoint4D * point4D)8566 Q3NURBPatch_SetControlPoint(TQ3GeometryObject nurbPatch, TQ3Uns32 rowIndex, TQ3Uns32 columnIndex, const TQ3RationalPoint4D *point4D)
8567 {
8568 // Release build checks
8569 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8570 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point4D), kQ3Failure);
8571
8572
8573
8574 // Debug build checks
8575 #if Q3_DEBUG
8576 TQ3NURBPatchData* instanceData = (TQ3NURBPatchData *) nurbPatch->FindLeafInstanceData () ;
8577
8578 if (0) // Further checks on nurbPatch
8579 return(kQ3Failure);
8580
8581 // Further checks on rowIndex
8582 if (rowIndex < 0 || rowIndex >= instanceData->numRows)
8583 return(kQ3Failure);
8584
8585 // Further checks on columnIndex
8586 if (columnIndex < 0 || columnIndex >= instanceData->numColumns)
8587 return(kQ3Failure);
8588
8589 if (0) // Further checks on point4D
8590 return(kQ3Failure);
8591 #endif
8592
8593
8594
8595 // Call the bottleneck
8596 E3System_Bottleneck();
8597
8598
8599
8600 // Call our implementation
8601 return(E3NURBPatch_SetControlPoint(nurbPatch, rowIndex, columnIndex, point4D));
8602 }
8603
8604
8605
8606
8607
8608 //=============================================================================
8609 // Q3NURBPatch_GetControlPoint : Quesa API entry point.
8610 //-----------------------------------------------------------------------------
8611 TQ3Status
Q3NURBPatch_GetControlPoint(TQ3GeometryObject nurbPatch,TQ3Uns32 rowIndex,TQ3Uns32 columnIndex,TQ3RationalPoint4D * point4D)8612 Q3NURBPatch_GetControlPoint(TQ3GeometryObject nurbPatch, TQ3Uns32 rowIndex, TQ3Uns32 columnIndex, TQ3RationalPoint4D *point4D)
8613 {
8614 // Release build checks
8615 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8616 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point4D), kQ3Failure);
8617
8618
8619
8620 // Debug build checks
8621 #if Q3_DEBUG
8622 TQ3NURBPatchData* instanceData = (TQ3NURBPatchData *) nurbPatch->FindLeafInstanceData () ;
8623
8624 if (0) // Further checks on nurbPatch
8625 return(kQ3Failure);
8626
8627 // Further checks on rowIndex
8628 if (rowIndex < 0 || rowIndex >= instanceData->numRows)
8629 return(kQ3Failure);
8630
8631 // Further checks on columnIndex
8632 if (columnIndex < 0 || columnIndex >= instanceData->numColumns)
8633 return(kQ3Failure);
8634
8635 if (0) // Further checks on point4D
8636 return(kQ3Failure);
8637 #endif
8638
8639
8640
8641 // Call the bottleneck
8642 E3System_Bottleneck();
8643
8644
8645
8646 // Call our implementation
8647 return(E3NURBPatch_GetControlPoint(nurbPatch, rowIndex, columnIndex, point4D));
8648 }
8649
8650
8651
8652
8653
8654 //=============================================================================
8655 // Q3NURBPatch_SetUKnot : Quesa API entry point.
8656 //-----------------------------------------------------------------------------
8657 TQ3Status
Q3NURBPatch_SetUKnot(TQ3GeometryObject nurbPatch,TQ3Uns32 knotIndex,float knotValue)8658 Q3NURBPatch_SetUKnot(TQ3GeometryObject nurbPatch, TQ3Uns32 knotIndex, float knotValue)
8659 {
8660 // Release build checks
8661 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8662
8663
8664
8665 // Debug build checks
8666 #if Q3_DEBUG
8667 TQ3NURBPatchData* instanceData = (TQ3NURBPatchData *) nurbPatch->FindLeafInstanceData () ;
8668
8669 if (0) // Further checks on nurbPatch
8670 return(kQ3Failure);
8671
8672 // Further checks on knotIndex
8673 if (knotIndex < 0
8674 ||
8675 knotIndex > instanceData->numColumns + instanceData->uOrder - 1)
8676 return(kQ3Failure);
8677
8678 // Further checks on knotValue
8679 if (knotIndex > 0
8680 &&
8681 knotValue < instanceData->uKnots[knotIndex - 1])
8682 return(kQ3Failure);
8683
8684 if (knotIndex < instanceData->numColumns + instanceData->uOrder - 1
8685 &&
8686 knotValue > instanceData->uKnots[knotIndex + 1])
8687 return(kQ3Failure);
8688 #endif
8689
8690
8691
8692 // Call the bottleneck
8693 E3System_Bottleneck();
8694
8695
8696
8697 // Call our implementation
8698 return(E3NURBPatch_SetUKnot(nurbPatch, knotIndex, knotValue));
8699 }
8700
8701
8702
8703
8704
8705 //=============================================================================
8706 // Q3NURBPatch_SetVKnot : Quesa API entry point.
8707 //-----------------------------------------------------------------------------
8708 TQ3Status
Q3NURBPatch_SetVKnot(TQ3GeometryObject nurbPatch,TQ3Uns32 knotIndex,float knotValue)8709 Q3NURBPatch_SetVKnot(TQ3GeometryObject nurbPatch, TQ3Uns32 knotIndex, float knotValue)
8710 {
8711 // Release build checks
8712 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8713
8714
8715
8716 // Debug build checks
8717 #if Q3_DEBUG
8718 TQ3NURBPatchData* instanceData = (TQ3NURBPatchData *) nurbPatch->FindLeafInstanceData () ;
8719
8720 if (0) // Further checks on nurbPatch
8721 return(kQ3Failure);
8722
8723 // Further checks on knotIndex
8724 if (knotIndex < 0 ||
8725 knotIndex > instanceData->numRows + instanceData->vOrder - 1)
8726 return(kQ3Failure);
8727
8728 // Further checks on knotValue
8729 if (knotIndex > 0 &&
8730 knotValue < instanceData->vKnots[knotIndex - 1])
8731 return(kQ3Failure);
8732
8733 if (knotIndex < (instanceData->numRows + instanceData->vOrder - 1) &&
8734 knotValue > instanceData->vKnots[knotIndex + 1])
8735 return(kQ3Failure);
8736 #endif
8737
8738
8739
8740 // Call the bottleneck
8741 E3System_Bottleneck();
8742
8743
8744
8745 // Call our implementation
8746 return(E3NURBPatch_SetVKnot(nurbPatch, knotIndex, knotValue));
8747 }
8748
8749
8750
8751
8752
8753 //=============================================================================
8754 // Q3NURBPatch_GetUKnot : Quesa API entry point.
8755 //-----------------------------------------------------------------------------
8756 TQ3Status
Q3NURBPatch_GetUKnot(TQ3GeometryObject nurbPatch,TQ3Uns32 knotIndex,float * knotValue)8757 Q3NURBPatch_GetUKnot(TQ3GeometryObject nurbPatch, TQ3Uns32 knotIndex, float *knotValue)
8758 {
8759 // Release build checks
8760 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8761 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(knotValue), kQ3Failure);
8762
8763
8764
8765 // Debug build checks
8766 #if Q3_DEBUG
8767 TQ3NURBPatchData* instanceData = (TQ3NURBPatchData *) nurbPatch->FindLeafInstanceData () ;
8768
8769 if (0) // Further checks on nurbPatch
8770 return(kQ3Failure);
8771
8772 // Further checks on knotIndex
8773 if (knotIndex < 0 || knotIndex > instanceData->numColumns + instanceData->uOrder - 1)
8774 return(kQ3Failure);
8775
8776 if (0) // Further checks on knotValue
8777 return(kQ3Failure);
8778 #endif
8779
8780
8781
8782 // Call the bottleneck
8783 E3System_Bottleneck();
8784
8785
8786
8787 // Call our implementation
8788 return(E3NURBPatch_GetUKnot(nurbPatch, knotIndex, knotValue));
8789 }
8790
8791
8792
8793
8794
8795 //=============================================================================
8796 // Q3NURBPatch_GetVKnot : Quesa API entry point.
8797 //-----------------------------------------------------------------------------
8798 TQ3Status
Q3NURBPatch_GetVKnot(TQ3GeometryObject nurbPatch,TQ3Uns32 knotIndex,float * knotValue)8799 Q3NURBPatch_GetVKnot(TQ3GeometryObject nurbPatch, TQ3Uns32 knotIndex, float *knotValue)
8800 {
8801 // Release build checks
8802 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( nurbPatch ), kQ3Failure);
8803 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(knotValue), kQ3Failure);
8804
8805
8806
8807 // Debug build checks
8808 #if Q3_DEBUG
8809 TQ3NURBPatchData* instanceData = (TQ3NURBPatchData*) nurbPatch->FindLeafInstanceData () ;
8810
8811 if (0) // Further checks on nurbPatch
8812 return(kQ3Failure);
8813
8814 // Further checks on knotIndex
8815 if (knotIndex < 0 || knotIndex > instanceData->numRows + instanceData->vOrder - 1)
8816 return(kQ3Failure);
8817
8818 if (0) // Further checks on knotValue
8819 return(kQ3Failure);
8820 #endif
8821
8822
8823
8824 // Call the bottleneck
8825 E3System_Bottleneck();
8826
8827
8828
8829 // Call our implementation
8830 return(E3NURBPatch_GetVKnot(nurbPatch, knotIndex, knotValue));
8831 }
8832
8833
8834
8835
8836
8837 //=============================================================================
8838 // Q3NURBPatch_EmptyData : Quesa API entry point.
8839 //-----------------------------------------------------------------------------
8840 TQ3Status
Q3NURBPatch_EmptyData(TQ3NURBPatchData * nurbPatchData)8841 Q3NURBPatch_EmptyData(TQ3NURBPatchData *nurbPatchData)
8842 {
8843
8844
8845 // Release build checks
8846 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(nurbPatchData), kQ3Failure);
8847
8848
8849
8850 // Debug build checks
8851 #if Q3_DEBUG
8852 if (0) // Further checks on nurbPatchData
8853 return(kQ3Failure);
8854 #endif
8855
8856
8857
8858 // Call the bottleneck
8859 E3System_Bottleneck();
8860
8861
8862
8863 // Call our implementation
8864 return(E3NURBPatch_EmptyData(nurbPatchData));
8865 }
8866
8867
8868
8869
8870
8871 //=============================================================================
8872 // Q3PixmapMarker_New : Quesa API entry point.
8873 //-----------------------------------------------------------------------------
8874 TQ3GeometryObject
Q3PixmapMarker_New(const TQ3PixmapMarkerData * pixmapMarkerData)8875 Q3PixmapMarker_New(const TQ3PixmapMarkerData *pixmapMarkerData)
8876 {
8877
8878
8879 // Release build checks
8880 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmapMarkerData), NULL);
8881
8882
8883
8884 // Debug build checks
8885 #if Q3_DEBUG
8886 if (0) // Further checks on pixmapMarkerData
8887 return(NULL);
8888 #endif
8889
8890
8891
8892 // Call the bottleneck
8893 E3System_Bottleneck();
8894
8895
8896
8897 // Call our implementation
8898 return(E3PixmapMarker_New(pixmapMarkerData));
8899 }
8900
8901
8902
8903
8904
8905 //=============================================================================
8906 // Q3PixmapMarker_Submit : Quesa API entry point.
8907 //-----------------------------------------------------------------------------
8908 TQ3Status
Q3PixmapMarker_Submit(const TQ3PixmapMarkerData * pixmapMarkerData,TQ3ViewObject view)8909 Q3PixmapMarker_Submit(const TQ3PixmapMarkerData *pixmapMarkerData, TQ3ViewObject view)
8910 {
8911
8912
8913 // Release build checks
8914 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmapMarkerData), kQ3Failure);
8915 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
8916
8917
8918
8919 // Debug build checks
8920 #if Q3_DEBUG
8921 if (0) // Further checks on pixmapMarkerData
8922 return(kQ3Failure);
8923
8924 if (0) // Further checks on view
8925 return(kQ3Failure);
8926 #endif
8927
8928
8929
8930 // Call the bottleneck
8931 E3System_Bottleneck();
8932
8933
8934
8935 // Call our implementation
8936 return(E3PixmapMarker_Submit(pixmapMarkerData, view));
8937 }
8938
8939
8940
8941
8942
8943 //=============================================================================
8944 // Q3PixmapMarker_SetData : Quesa API entry point.
8945 //-----------------------------------------------------------------------------
8946 TQ3Status
Q3PixmapMarker_SetData(TQ3GeometryObject geometry,const TQ3PixmapMarkerData * pixmapMarkerData)8947 Q3PixmapMarker_SetData(TQ3GeometryObject geometry, const TQ3PixmapMarkerData *pixmapMarkerData)
8948 {
8949
8950
8951 // Release build checks
8952 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
8953 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmapMarkerData), kQ3Failure);
8954
8955
8956
8957 // Debug build checks
8958 #if Q3_DEBUG
8959 if (0) // Further checks on geometry
8960 return(kQ3Failure);
8961
8962 if (0) // Further checks on pixmapMarkerData
8963 return(kQ3Failure);
8964 #endif
8965
8966
8967
8968 // Call the bottleneck
8969 E3System_Bottleneck();
8970
8971
8972
8973 // Call our implementation
8974 return(E3PixmapMarker_SetData(geometry, pixmapMarkerData));
8975 }
8976
8977
8978
8979
8980
8981 //=============================================================================
8982 // Q3PixmapMarker_GetData : Quesa API entry point.
8983 //-----------------------------------------------------------------------------
8984 TQ3Status
Q3PixmapMarker_GetData(TQ3GeometryObject geometry,TQ3PixmapMarkerData * pixmapMarkerData)8985 Q3PixmapMarker_GetData(TQ3GeometryObject geometry, TQ3PixmapMarkerData *pixmapMarkerData)
8986 {
8987
8988
8989 // Release build checks
8990 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( geometry ), kQ3Failure);
8991 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmapMarkerData), kQ3Failure);
8992
8993
8994
8995 // Debug build checks
8996 #if Q3_DEBUG
8997 if (0) // Further checks on geometry
8998 return(kQ3Failure);
8999
9000 if (0) // Further checks on pixmapMarkerData
9001 return(kQ3Failure);
9002 #endif
9003
9004
9005
9006 // Call the bottleneck
9007 E3System_Bottleneck();
9008
9009
9010
9011 // Call our implementation
9012 return(E3PixmapMarker_GetData(geometry, pixmapMarkerData));
9013 }
9014
9015
9016
9017
9018
9019 //=============================================================================
9020 // Q3PixmapMarker_EmptyData : Quesa API entry point.
9021 //-----------------------------------------------------------------------------
9022 TQ3Status
Q3PixmapMarker_EmptyData(TQ3PixmapMarkerData * pixmapMarkerData)9023 Q3PixmapMarker_EmptyData(TQ3PixmapMarkerData *pixmapMarkerData)
9024 {
9025
9026
9027 // Release build checks
9028 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmapMarkerData), kQ3Failure);
9029
9030
9031
9032 // Debug build checks
9033 #if Q3_DEBUG
9034 if (0) // Further checks on pixmapMarkerData
9035 return(kQ3Failure);
9036 #endif
9037
9038
9039
9040 // Call the bottleneck
9041 E3System_Bottleneck();
9042
9043
9044
9045 // Call our implementation
9046 return(E3PixmapMarker_EmptyData(pixmapMarkerData));
9047 }
9048
9049
9050
9051
9052
9053 //=============================================================================
9054 // Q3PixmapMarker_GetPosition : Quesa API entry point.
9055 //-----------------------------------------------------------------------------
9056 TQ3Status
Q3PixmapMarker_GetPosition(TQ3GeometryObject pixmapMarker,TQ3Point3D * position)9057 Q3PixmapMarker_GetPosition(TQ3GeometryObject pixmapMarker, TQ3Point3D *position)
9058 {
9059
9060
9061 // Release build checks
9062 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9063 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
9064
9065
9066
9067 // Debug build checks
9068 #if Q3_DEBUG
9069 if (0) // Further checks on pixmapMarker
9070 return(kQ3Failure);
9071
9072 if (0) // Further checks on position
9073 return(kQ3Failure);
9074 #endif
9075
9076
9077
9078 // Call the bottleneck
9079 E3System_Bottleneck();
9080
9081
9082
9083 // Call our implementation
9084 return(E3PixmapMarker_GetPosition(pixmapMarker, position));
9085 }
9086
9087
9088
9089
9090
9091 //=============================================================================
9092 // Q3PixmapMarker_SetPosition : Quesa API entry point.
9093 //-----------------------------------------------------------------------------
9094 TQ3Status
Q3PixmapMarker_SetPosition(TQ3GeometryObject pixmapMarker,const TQ3Point3D * position)9095 Q3PixmapMarker_SetPosition(TQ3GeometryObject pixmapMarker, const TQ3Point3D *position)
9096 {
9097
9098
9099 // Release build checks
9100 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9101 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
9102
9103
9104
9105 // Debug build checks
9106 #if Q3_DEBUG
9107 if (0) // Further checks on pixmapMarker
9108 return(kQ3Failure);
9109
9110 if (0) // Further checks on position
9111 return(kQ3Failure);
9112 #endif
9113
9114
9115
9116 // Call the bottleneck
9117 E3System_Bottleneck();
9118
9119
9120
9121 // Call our implementation
9122 return(E3PixmapMarker_SetPosition(pixmapMarker, position));
9123 }
9124
9125
9126
9127
9128
9129 //=============================================================================
9130 // Q3PixmapMarker_GetXOffset : Quesa API entry point.
9131 //-----------------------------------------------------------------------------
9132 TQ3Status
Q3PixmapMarker_GetXOffset(TQ3GeometryObject pixmapMarker,TQ3Int32 * xOffset)9133 Q3PixmapMarker_GetXOffset(TQ3GeometryObject pixmapMarker, TQ3Int32 *xOffset)
9134 {
9135
9136
9137 // Release build checks
9138 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9139 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(xOffset), kQ3Failure);
9140
9141
9142
9143 // Debug build checks
9144 #if Q3_DEBUG
9145 if (0) // Further checks on pixmapMarker
9146 return(kQ3Failure);
9147
9148 if (0) // Further checks on xOffset
9149 return(kQ3Failure);
9150 #endif
9151
9152
9153
9154 // Call the bottleneck
9155 E3System_Bottleneck();
9156
9157
9158
9159 // Call our implementation
9160 return(E3PixmapMarker_GetXOffset(pixmapMarker, xOffset));
9161 }
9162
9163
9164
9165
9166
9167 //=============================================================================
9168 // Q3PixmapMarker_SetXOffset : Quesa API entry point.
9169 //-----------------------------------------------------------------------------
9170 TQ3Status
Q3PixmapMarker_SetXOffset(TQ3GeometryObject pixmapMarker,TQ3Int32 xOffset)9171 Q3PixmapMarker_SetXOffset(TQ3GeometryObject pixmapMarker, TQ3Int32 xOffset)
9172 {
9173
9174
9175 // Release build checks
9176 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9177
9178
9179
9180 // Debug build checks
9181 #if Q3_DEBUG
9182 if (0) // Further checks on pixmapMarker
9183 return(kQ3Failure);
9184
9185 if (0) // Further checks on xOffset
9186 return(kQ3Failure);
9187 #endif
9188
9189
9190
9191 // Call the bottleneck
9192 E3System_Bottleneck();
9193
9194
9195
9196 // Call our implementation
9197 return(E3PixmapMarker_SetXOffset(pixmapMarker, xOffset));
9198 }
9199
9200
9201
9202
9203
9204 //=============================================================================
9205 // Q3PixmapMarker_GetYOffset : Quesa API entry point.
9206 //-----------------------------------------------------------------------------
9207 TQ3Status
Q3PixmapMarker_GetYOffset(TQ3GeometryObject pixmapMarker,TQ3Int32 * yOffset)9208 Q3PixmapMarker_GetYOffset(TQ3GeometryObject pixmapMarker, TQ3Int32 *yOffset)
9209 {
9210
9211
9212 // Release build checks
9213 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9214 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(yOffset), kQ3Failure);
9215
9216
9217
9218 // Debug build checks
9219 #if Q3_DEBUG
9220 if (0) // Further checks on pixmapMarker
9221 return(kQ3Failure);
9222
9223 if (0) // Further checks on yOffset
9224 return(kQ3Failure);
9225 #endif
9226
9227
9228
9229 // Call the bottleneck
9230 E3System_Bottleneck();
9231
9232
9233
9234 // Call our implementation
9235 return(E3PixmapMarker_GetYOffset(pixmapMarker, yOffset));
9236 }
9237
9238
9239
9240
9241
9242 //=============================================================================
9243 // Q3PixmapMarker_SetYOffset : Quesa API entry point.
9244 //-----------------------------------------------------------------------------
9245 TQ3Status
Q3PixmapMarker_SetYOffset(TQ3GeometryObject pixmapMarker,TQ3Int32 yOffset)9246 Q3PixmapMarker_SetYOffset(TQ3GeometryObject pixmapMarker, TQ3Int32 yOffset)
9247 {
9248
9249
9250 // Release build checks
9251 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9252
9253
9254
9255 // Debug build checks
9256 #if Q3_DEBUG
9257 if (0) // Further checks on pixmapMarker
9258 return(kQ3Failure);
9259
9260 if (0) // Further checks on yOffset
9261 return(kQ3Failure);
9262 #endif
9263
9264
9265
9266 // Call the bottleneck
9267 E3System_Bottleneck();
9268
9269
9270
9271 // Call our implementation
9272 return(E3PixmapMarker_SetYOffset(pixmapMarker, yOffset));
9273 }
9274
9275
9276
9277
9278
9279 //=============================================================================
9280 // Q3PixmapMarker_GetPixmap : Quesa API entry point.
9281 //-----------------------------------------------------------------------------
9282 TQ3Status
Q3PixmapMarker_GetPixmap(TQ3GeometryObject pixmapMarker,TQ3StoragePixmap * pixmap)9283 Q3PixmapMarker_GetPixmap(TQ3GeometryObject pixmapMarker, TQ3StoragePixmap *pixmap)
9284 {
9285
9286
9287 // Release build checks
9288 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9289 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmap), kQ3Failure);
9290
9291
9292
9293 // Debug build checks
9294 #if Q3_DEBUG
9295 if (0) // Further checks on pixmapMarker
9296 return(kQ3Failure);
9297
9298 if (0) // Further checks on pixmap
9299 return(kQ3Failure);
9300 #endif
9301
9302
9303
9304 // Call the bottleneck
9305 E3System_Bottleneck();
9306
9307
9308
9309 // Call our implementation
9310 return(E3PixmapMarker_GetPixmap(pixmapMarker, pixmap));
9311 }
9312
9313
9314
9315
9316
9317 //=============================================================================
9318 // Q3PixmapMarker_SetPixmap : Quesa API entry point.
9319 //-----------------------------------------------------------------------------
9320 TQ3Status
Q3PixmapMarker_SetPixmap(TQ3GeometryObject pixmapMarker,const TQ3StoragePixmap * pixmap)9321 Q3PixmapMarker_SetPixmap(TQ3GeometryObject pixmapMarker, const TQ3StoragePixmap *pixmap)
9322 {
9323
9324
9325 // Release build checks
9326 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( pixmapMarker ), kQ3Failure);
9327 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pixmap), kQ3Failure);
9328
9329
9330
9331 // Debug build checks
9332 #if Q3_DEBUG
9333 if (0) // Further checks on pixmapMarker
9334 return(kQ3Failure);
9335
9336 if (0) // Further checks on pixmap
9337 return(kQ3Failure);
9338 #endif
9339
9340
9341
9342 // Call the bottleneck
9343 E3System_Bottleneck();
9344
9345
9346
9347 // Call our implementation
9348 return(E3PixmapMarker_SetPixmap(pixmapMarker, pixmap));
9349 }
9350
9351
9352
9353
9354
9355 //=============================================================================
9356 // Q3Point_New : Quesa API entry point.
9357 //-----------------------------------------------------------------------------
9358 TQ3GeometryObject
Q3Point_New(const TQ3PointData * pointData)9359 Q3Point_New(const TQ3PointData *pointData)
9360 {
9361
9362
9363 // Release build checks
9364 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pointData) || (pointData == NULL), NULL);
9365
9366
9367
9368 // Debug build checks
9369 #if Q3_DEBUG
9370 if (0) // Further checks on pointData
9371 return(NULL);
9372 #endif
9373
9374
9375
9376 // Call the bottleneck
9377 E3System_Bottleneck();
9378
9379
9380
9381 // Call our implementation
9382 return(E3Point_New(pointData));
9383 }
9384
9385
9386
9387
9388
9389 //=============================================================================
9390 // Q3Point_Submit : Quesa API entry point.
9391 //-----------------------------------------------------------------------------
9392 TQ3Status
Q3Point_Submit(const TQ3PointData * pointData,TQ3ViewObject view)9393 Q3Point_Submit(const TQ3PointData *pointData, TQ3ViewObject view)
9394 {
9395
9396
9397 // Release build checks
9398 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pointData), kQ3Failure);
9399 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
9400
9401
9402
9403 // Debug build checks
9404 #if Q3_DEBUG
9405 if (0) // Further checks on pointData
9406 return(kQ3Failure);
9407
9408 if (0) // Further checks on view
9409 return(kQ3Failure);
9410 #endif
9411
9412
9413
9414 // Call the bottleneck
9415 E3System_Bottleneck();
9416
9417
9418
9419 // Call our implementation
9420 return(E3Point_Submit(pointData, view));
9421 }
9422
9423
9424
9425
9426
9427 //=============================================================================
9428 // Q3Point_GetData : Quesa API entry point.
9429 //-----------------------------------------------------------------------------
9430 TQ3Status
Q3Point_GetData(TQ3GeometryObject point,TQ3PointData * pointData)9431 Q3Point_GetData(TQ3GeometryObject point, TQ3PointData *pointData)
9432 {
9433
9434
9435 // Release build checks
9436 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( point ), kQ3Failure);
9437 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pointData), kQ3Failure);
9438
9439
9440
9441 // Debug build checks
9442 #if Q3_DEBUG
9443 if (0) // Further checks on point
9444 return(kQ3Failure);
9445
9446 if (0) // Further checks on pointData
9447 return(kQ3Failure);
9448 #endif
9449
9450
9451
9452 // Call the bottleneck
9453 E3System_Bottleneck();
9454
9455
9456
9457 // Call our implementation
9458 return(E3Point_GetData(point, pointData));
9459 }
9460
9461
9462
9463
9464
9465 //=============================================================================
9466 // Q3Point_SetData : Quesa API entry point.
9467 //-----------------------------------------------------------------------------
9468 TQ3Status
Q3Point_SetData(TQ3GeometryObject point,const TQ3PointData * pointData)9469 Q3Point_SetData(TQ3GeometryObject point, const TQ3PointData *pointData)
9470 {
9471
9472
9473 // Release build checks
9474 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( point ), kQ3Failure);
9475 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pointData), kQ3Failure);
9476
9477
9478
9479 // Debug build checks
9480 #if Q3_DEBUG
9481 if (0) // Further checks on point
9482 return(kQ3Failure);
9483
9484 if (0) // Further checks on pointData
9485 return(kQ3Failure);
9486 #endif
9487
9488
9489
9490 // Call the bottleneck
9491 E3System_Bottleneck();
9492
9493
9494
9495 // Call our implementation
9496 return(E3Point_SetData(point, pointData));
9497 }
9498
9499
9500
9501
9502
9503 //=============================================================================
9504 // Q3Point_EmptyData : Quesa API entry point.
9505 //-----------------------------------------------------------------------------
9506 TQ3Status
Q3Point_EmptyData(TQ3PointData * pointData)9507 Q3Point_EmptyData(TQ3PointData *pointData)
9508 {
9509
9510
9511 // Release build checks
9512 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(pointData), kQ3Failure);
9513
9514
9515
9516 // Debug build checks
9517 #if Q3_DEBUG
9518 if (0) // Further checks on pointData
9519 return(kQ3Failure);
9520 #endif
9521
9522
9523
9524 // Call the bottleneck
9525 E3System_Bottleneck();
9526
9527
9528
9529 // Call our implementation
9530 return(E3Point_EmptyData(pointData));
9531 }
9532
9533
9534
9535
9536
9537 //=============================================================================
9538 // Q3Point_SetPosition : Quesa API entry point.
9539 //-----------------------------------------------------------------------------
9540 TQ3Status
Q3Point_SetPosition(TQ3GeometryObject point,const TQ3Point3D * position)9541 Q3Point_SetPosition(TQ3GeometryObject point, const TQ3Point3D *position)
9542 {
9543
9544
9545 // Release build checks
9546 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( point ), kQ3Failure);
9547 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
9548
9549
9550
9551 // Debug build checks
9552 #if Q3_DEBUG
9553 if (0) // Further checks on point
9554 return(kQ3Failure);
9555
9556 if (0) // Further checks on position
9557 return(kQ3Failure);
9558 #endif
9559
9560
9561
9562 // Call the bottleneck
9563 E3System_Bottleneck();
9564
9565
9566
9567 // Call our implementation
9568 return(E3Point_SetPosition(point, position));
9569 }
9570
9571
9572
9573
9574
9575 //=============================================================================
9576 // Q3Point_GetPosition : Quesa API entry point.
9577 //-----------------------------------------------------------------------------
9578 TQ3Status
Q3Point_GetPosition(TQ3GeometryObject point,TQ3Point3D * position)9579 Q3Point_GetPosition(TQ3GeometryObject point, TQ3Point3D *position)
9580 {
9581
9582
9583 // Release build checks
9584 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( point ), kQ3Failure);
9585 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
9586
9587
9588
9589 // Debug build checks
9590 #if Q3_DEBUG
9591 if (0) // Further checks on point
9592 return(kQ3Failure);
9593
9594 if (0) // Further checks on position
9595 return(kQ3Failure);
9596 #endif
9597
9598
9599
9600 // Call the bottleneck
9601 E3System_Bottleneck();
9602
9603
9604
9605 // Call our implementation
9606 return(E3Point_GetPosition(point, position));
9607 }
9608
9609
9610
9611
9612
9613 //=============================================================================
9614 // Q3Polygon_New : Quesa API entry point.
9615 //-----------------------------------------------------------------------------
9616 TQ3GeometryObject
Q3Polygon_New(const TQ3PolygonData * polygonData)9617 Q3Polygon_New(const TQ3PolygonData *polygonData)
9618 {
9619
9620
9621 // Release build checks
9622 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polygonData), NULL);
9623 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polygonData->vertices), NULL);
9624
9625
9626
9627 // Debug build checks
9628 #if Q3_DEBUG
9629 if (polygonData->numVertices < 3)
9630 return(NULL);
9631 #endif
9632
9633
9634
9635 // Call the bottleneck
9636 E3System_Bottleneck();
9637
9638
9639
9640 // Call our implementation
9641 return(E3Polygon_New(polygonData));
9642 }
9643
9644
9645
9646
9647
9648 //=============================================================================
9649 // Q3Polygon_Submit : Quesa API entry point.
9650 //-----------------------------------------------------------------------------
9651 TQ3Status
Q3Polygon_Submit(const TQ3PolygonData * polygonData,TQ3ViewObject view)9652 Q3Polygon_Submit(const TQ3PolygonData *polygonData, TQ3ViewObject view)
9653 {
9654
9655
9656 // Release build checks
9657 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polygonData), kQ3Failure);
9658 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
9659
9660
9661
9662 // Debug build checks
9663 #if Q3_DEBUG
9664 if (0) // Further checks on polygonData
9665 return(kQ3Failure);
9666
9667 if (0) // Further checks on view
9668 return(kQ3Failure);
9669 #endif
9670
9671
9672
9673 // Call the bottleneck
9674 E3System_Bottleneck();
9675
9676
9677
9678 // Call our implementation
9679 return(E3Polygon_Submit(polygonData, view));
9680 }
9681
9682
9683
9684
9685
9686 //=============================================================================
9687 // Q3Polygon_SetData : Quesa API entry point.
9688 //-----------------------------------------------------------------------------
9689 TQ3Status
Q3Polygon_SetData(TQ3GeometryObject polygon,const TQ3PolygonData * polygonData)9690 Q3Polygon_SetData(TQ3GeometryObject polygon, const TQ3PolygonData *polygonData)
9691 {
9692
9693
9694 // Release build checks
9695 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
9696 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polygonData), kQ3Failure);
9697
9698
9699
9700 // Debug build checks
9701 #if Q3_DEBUG
9702 if (0) // Further checks on polygon
9703 return(kQ3Failure);
9704
9705 if (0) // Further checks on polygonData
9706 return(kQ3Failure);
9707 #endif
9708
9709
9710
9711 // Call the bottleneck
9712 E3System_Bottleneck();
9713
9714
9715
9716 // Call our implementation
9717 return(E3Polygon_SetData(polygon, polygonData));
9718 }
9719
9720
9721
9722
9723
9724 //=============================================================================
9725 // Q3Polygon_GetData : Quesa API entry point.
9726 //-----------------------------------------------------------------------------
9727 TQ3Status
Q3Polygon_GetData(TQ3GeometryObject polygon,TQ3PolygonData * polygonData)9728 Q3Polygon_GetData(TQ3GeometryObject polygon, TQ3PolygonData *polygonData)
9729 {
9730
9731
9732 // Release build checks
9733 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
9734 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polygonData), kQ3Failure);
9735
9736
9737
9738 // Debug build checks
9739 #if Q3_DEBUG
9740 if (0) // Further checks on polygon
9741 return(kQ3Failure);
9742
9743 if (0) // Further checks on polygonData
9744 return(kQ3Failure);
9745 #endif
9746
9747
9748
9749 // Call the bottleneck
9750 E3System_Bottleneck();
9751
9752
9753
9754 // Call our implementation
9755 return(E3Polygon_GetData(polygon, polygonData));
9756 }
9757
9758
9759
9760
9761
9762 //=============================================================================
9763 // Q3Polygon_EmptyData : Quesa API entry point.
9764 //-----------------------------------------------------------------------------
9765 TQ3Status
Q3Polygon_EmptyData(TQ3PolygonData * polygonData)9766 Q3Polygon_EmptyData(TQ3PolygonData *polygonData)
9767 {
9768
9769
9770 // Release build checks
9771 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polygonData), kQ3Failure);
9772
9773
9774
9775 // Debug build checks
9776 #if Q3_DEBUG
9777 if (0) // Further checks on polygonData
9778 return(kQ3Failure);
9779 #endif
9780
9781
9782
9783 // Call the bottleneck
9784 E3System_Bottleneck();
9785
9786
9787
9788 // Call our implementation
9789 return(E3Polygon_EmptyData(polygonData));
9790 }
9791
9792
9793
9794
9795
9796 //=============================================================================
9797 // Q3Polygon_GetVertexPosition : Quesa API entry point.
9798 //-----------------------------------------------------------------------------
9799 TQ3Status
Q3Polygon_GetVertexPosition(TQ3GeometryObject polygon,TQ3Uns32 index,TQ3Point3D * point)9800 Q3Polygon_GetVertexPosition(TQ3GeometryObject polygon, TQ3Uns32 index, TQ3Point3D *point)
9801 {
9802
9803
9804 // Release build checks
9805 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
9806 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point), kQ3Failure);
9807
9808
9809
9810 // Debug build checks
9811 #if Q3_DEBUG
9812 if (0) // Further checks on polygon
9813 return(kQ3Failure);
9814
9815 if (0) // Further checks on index
9816 return(kQ3Failure);
9817
9818 if (0) // Further checks on point
9819 return(kQ3Failure);
9820 #endif
9821
9822
9823
9824 // Call the bottleneck
9825 E3System_Bottleneck();
9826
9827
9828
9829 // Call our implementation
9830 return(E3Polygon_GetVertexPosition(polygon, index, point));
9831 }
9832
9833
9834
9835
9836
9837 //=============================================================================
9838 // Q3Polygon_SetVertexPosition : Quesa API entry point.
9839 //-----------------------------------------------------------------------------
9840 TQ3Status
Q3Polygon_SetVertexPosition(TQ3GeometryObject polygon,TQ3Uns32 index,const TQ3Point3D * point)9841 Q3Polygon_SetVertexPosition(TQ3GeometryObject polygon, TQ3Uns32 index, const TQ3Point3D *point)
9842 {
9843
9844
9845 // Release build checks
9846 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
9847 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point), kQ3Failure);
9848
9849
9850
9851 // Debug build checks
9852 #if Q3_DEBUG
9853 if (0) // Further checks on polygon
9854 return(kQ3Failure);
9855
9856 if (0) // Further checks on index
9857 return(kQ3Failure);
9858
9859 if (0) // Further checks on point
9860 return(kQ3Failure);
9861 #endif
9862
9863
9864
9865 // Call the bottleneck
9866 E3System_Bottleneck();
9867
9868
9869
9870 // Call our implementation
9871 return(E3Polygon_SetVertexPosition(polygon, index, point));
9872 }
9873
9874
9875
9876
9877
9878 //=============================================================================
9879 // Q3Polygon_GetVertexAttributeSet : Quesa API entry point.
9880 //-----------------------------------------------------------------------------
9881 TQ3Status
Q3Polygon_GetVertexAttributeSet(TQ3GeometryObject polygon,TQ3Uns32 index,TQ3AttributeSet * attributeSet)9882 Q3Polygon_GetVertexAttributeSet(TQ3GeometryObject polygon, TQ3Uns32 index, TQ3AttributeSet *attributeSet)
9883 {
9884
9885
9886 // Release build checks
9887 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
9888 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
9889
9890
9891
9892 // Debug build checks
9893 #if Q3_DEBUG
9894 if (0) // Further checks on polygon
9895 return(kQ3Failure);
9896
9897 if (0) // Further checks on index
9898 return(kQ3Failure);
9899
9900 if (0) // Further checks on attributeSet
9901 return(kQ3Failure);
9902 #endif
9903
9904
9905
9906 // Call the bottleneck
9907 E3System_Bottleneck();
9908
9909
9910
9911 // Call our implementation
9912 return(E3Polygon_GetVertexAttributeSet(polygon, index, attributeSet));
9913 }
9914
9915
9916
9917
9918
9919 //=============================================================================
9920 // Q3Polygon_SetVertexAttributeSet : Quesa API entry point.
9921 //-----------------------------------------------------------------------------
9922 TQ3Status
Q3Polygon_SetVertexAttributeSet(TQ3GeometryObject polygon,TQ3Uns32 index,TQ3AttributeSet attributeSet)9923 Q3Polygon_SetVertexAttributeSet(TQ3GeometryObject polygon, TQ3Uns32 index, TQ3AttributeSet attributeSet)
9924 {
9925
9926
9927 // Release build checks
9928 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polygon ), kQ3Failure);
9929
9930
9931
9932 // Debug build checks
9933 #if Q3_DEBUG
9934 if (0) // Further checks on polygon
9935 return(kQ3Failure);
9936
9937 if (0) // Further checks on index
9938 return(kQ3Failure);
9939
9940 if (0) // Further checks on attributeSet
9941 return(kQ3Failure);
9942 #endif
9943
9944
9945
9946 // Call the bottleneck
9947 E3System_Bottleneck();
9948
9949
9950
9951 // Call our implementation
9952 return(E3Polygon_SetVertexAttributeSet(polygon, index, attributeSet));
9953 }
9954
9955
9956
9957
9958
9959 //=============================================================================
9960 // Q3Polyhedron_New : Quesa API entry point.
9961 //-----------------------------------------------------------------------------
9962 TQ3GeometryObject
Q3Polyhedron_New(const TQ3PolyhedronData * polyhedronData)9963 Q3Polyhedron_New(const TQ3PolyhedronData *polyhedronData)
9964 {
9965
9966
9967 // Release build checks
9968 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyhedronData), NULL);
9969
9970
9971
9972 // Debug build checks
9973 #if Q3_DEBUG
9974 if (0) // Further checks on polyhedronData
9975 return(NULL);
9976 #endif
9977
9978
9979
9980 // Call the bottleneck
9981 E3System_Bottleneck();
9982
9983
9984
9985 // Call our implementation
9986 return(E3Polyhedron_New(polyhedronData));
9987 }
9988
9989
9990
9991
9992
9993 //=============================================================================
9994 // Q3Polyhedron_Submit : Quesa API entry point.
9995 //-----------------------------------------------------------------------------
9996 TQ3Status
Q3Polyhedron_Submit(const TQ3PolyhedronData * polyhedronData,TQ3ViewObject view)9997 Q3Polyhedron_Submit(const TQ3PolyhedronData *polyhedronData, TQ3ViewObject view)
9998 {
9999
10000
10001 // Release build checks
10002 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyhedronData), kQ3Failure);
10003 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
10004
10005
10006
10007 // Debug build checks
10008 #if Q3_DEBUG
10009 if (0) // Further checks on polyhedronData
10010 return(kQ3Failure);
10011
10012 if (0) // Further checks on view
10013 return(kQ3Failure);
10014 #endif
10015
10016
10017
10018 // Call the bottleneck
10019 E3System_Bottleneck();
10020
10021
10022
10023 // Call our implementation
10024 return(E3Polyhedron_Submit(polyhedronData, view));
10025 }
10026
10027
10028
10029
10030
10031 //=============================================================================
10032 // Q3Polyhedron_SetData : Quesa API entry point.
10033 //-----------------------------------------------------------------------------
10034 TQ3Status
Q3Polyhedron_SetData(TQ3GeometryObject polyhedron,const TQ3PolyhedronData * polyhedronData)10035 Q3Polyhedron_SetData(TQ3GeometryObject polyhedron, const TQ3PolyhedronData *polyhedronData)
10036 {
10037
10038
10039 // Release build checks
10040 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10041 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyhedronData), kQ3Failure);
10042
10043
10044
10045 // Debug build checks
10046 #if Q3_DEBUG
10047 if (0) // Further checks on polyhedron
10048 return(kQ3Failure);
10049
10050 if (0) // Further checks on polyhedronData
10051 return(kQ3Failure);
10052 #endif
10053
10054
10055
10056 // Call the bottleneck
10057 E3System_Bottleneck();
10058
10059
10060
10061 // Call our implementation
10062 return(E3Polyhedron_SetData(polyhedron, polyhedronData));
10063 }
10064
10065
10066
10067
10068
10069 //=============================================================================
10070 // Q3Polyhedron_GetData : Quesa API entry point.
10071 //-----------------------------------------------------------------------------
10072 TQ3Status
Q3Polyhedron_GetData(TQ3GeometryObject polyhedron,TQ3PolyhedronData * polyhedronData)10073 Q3Polyhedron_GetData(TQ3GeometryObject polyhedron, TQ3PolyhedronData *polyhedronData)
10074 {
10075
10076
10077 // Release build checks
10078 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10079 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyhedronData), kQ3Failure);
10080
10081
10082
10083 // Debug build checks
10084 #if Q3_DEBUG
10085 if (0) // Further checks on polyhedron
10086 return(kQ3Failure);
10087
10088 if (0) // Further checks on polyhedronData
10089 return(kQ3Failure);
10090 #endif
10091
10092
10093
10094 // Call the bottleneck
10095 E3System_Bottleneck();
10096
10097
10098
10099 // Call our implementation
10100 return(E3Polyhedron_GetData(polyhedron, polyhedronData));
10101 }
10102
10103
10104
10105
10106
10107 //=============================================================================
10108 // Q3Polyhedron_EmptyData : Quesa API entry point.
10109 //-----------------------------------------------------------------------------
10110 TQ3Status
Q3Polyhedron_EmptyData(TQ3PolyhedronData * polyhedronData)10111 Q3Polyhedron_EmptyData(TQ3PolyhedronData *polyhedronData)
10112 {
10113
10114
10115 // Release build checks
10116 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyhedronData), kQ3Failure);
10117
10118
10119
10120 // Debug build checks
10121 #if Q3_DEBUG
10122 if (0) // Further checks on polyhedronData
10123 return(kQ3Failure);
10124 #endif
10125
10126
10127
10128 // Call the bottleneck
10129 E3System_Bottleneck();
10130
10131
10132
10133 // Call our implementation
10134 return(E3Polyhedron_EmptyData(polyhedronData));
10135 }
10136
10137
10138
10139
10140
10141 //=============================================================================
10142 // Q3Polyhedron_SetVertexPosition : Quesa API entry point.
10143 //-----------------------------------------------------------------------------
10144 TQ3Status
Q3Polyhedron_SetVertexPosition(TQ3GeometryObject polyhedron,TQ3Uns32 index,const TQ3Point3D * point)10145 Q3Polyhedron_SetVertexPosition(TQ3GeometryObject polyhedron, TQ3Uns32 index, const TQ3Point3D *point)
10146 {
10147
10148
10149 // Release build checks
10150 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10151 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point), kQ3Failure);
10152
10153
10154
10155 // Debug build checks
10156 #if Q3_DEBUG
10157 if (0) // Further checks on polyhedron
10158 return(kQ3Failure);
10159
10160 if (0) // Further checks on index
10161 return(kQ3Failure);
10162
10163 if (0) // Further checks on point
10164 return(kQ3Failure);
10165 #endif
10166
10167
10168
10169 // Call the bottleneck
10170 E3System_Bottleneck();
10171
10172
10173
10174 // Call our implementation
10175 return(E3Polyhedron_SetVertexPosition(polyhedron, index, point));
10176 }
10177
10178
10179
10180
10181
10182 //=============================================================================
10183 // Q3Polyhedron_GetVertexPosition : Quesa API entry point.
10184 //-----------------------------------------------------------------------------
10185 TQ3Status
Q3Polyhedron_GetVertexPosition(TQ3GeometryObject polyhedron,TQ3Uns32 index,TQ3Point3D * point)10186 Q3Polyhedron_GetVertexPosition(TQ3GeometryObject polyhedron, TQ3Uns32 index, TQ3Point3D *point)
10187 {
10188
10189
10190 // Release build checks
10191 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10192 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point), kQ3Failure);
10193
10194
10195
10196 // Debug build checks
10197 #if Q3_DEBUG
10198 if (0) // Further checks on polyhedron
10199 return(kQ3Failure);
10200
10201 if (0) // Further checks on index
10202 return(kQ3Failure);
10203
10204 if (0) // Further checks on point
10205 return(kQ3Failure);
10206 #endif
10207
10208
10209
10210 // Call the bottleneck
10211 E3System_Bottleneck();
10212
10213
10214
10215 // Call our implementation
10216 return(E3Polyhedron_GetVertexPosition(polyhedron, index, point));
10217 }
10218
10219
10220
10221
10222
10223 //=============================================================================
10224 // Q3Polyhedron_SetVertexAttributeSet : Quesa API entry point.
10225 //-----------------------------------------------------------------------------
10226 TQ3Status
Q3Polyhedron_SetVertexAttributeSet(TQ3GeometryObject polyhedron,TQ3Uns32 index,TQ3AttributeSet attributeSet)10227 Q3Polyhedron_SetVertexAttributeSet(TQ3GeometryObject polyhedron, TQ3Uns32 index, TQ3AttributeSet attributeSet)
10228 {
10229
10230
10231 // Release build checks
10232 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10233
10234
10235
10236 // Debug build checks
10237 #if Q3_DEBUG
10238 if (0) // Further checks on polyhedron
10239 return(kQ3Failure);
10240
10241 if (0) // Further checks on index
10242 return(kQ3Failure);
10243
10244 if (0) // Further checks on attributeSet
10245 return(kQ3Failure);
10246 #endif
10247
10248
10249
10250 // Call the bottleneck
10251 E3System_Bottleneck();
10252
10253
10254
10255 // Call our implementation
10256 return(E3Polyhedron_SetVertexAttributeSet(polyhedron, index, attributeSet));
10257 }
10258
10259
10260
10261
10262
10263 //=============================================================================
10264 // Q3Polyhedron_GetVertexAttributeSet : Quesa API entry point.
10265 //-----------------------------------------------------------------------------
10266 TQ3Status
Q3Polyhedron_GetVertexAttributeSet(TQ3GeometryObject polyhedron,TQ3Uns32 index,TQ3AttributeSet * attributeSet)10267 Q3Polyhedron_GetVertexAttributeSet(TQ3GeometryObject polyhedron, TQ3Uns32 index, TQ3AttributeSet *attributeSet)
10268 {
10269
10270
10271 // Release build checks
10272 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10273 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
10274
10275
10276
10277 // Debug build checks
10278 #if Q3_DEBUG
10279 if (0) // Further checks on polyhedron
10280 return(kQ3Failure);
10281
10282 if (0) // Further checks on index
10283 return(kQ3Failure);
10284
10285 if (0) // Further checks on attributeSet
10286 return(kQ3Failure);
10287 #endif
10288
10289
10290
10291 // Call the bottleneck
10292 E3System_Bottleneck();
10293
10294
10295
10296 // Call our implementation
10297 return(E3Polyhedron_GetVertexAttributeSet(polyhedron, index, attributeSet));
10298 }
10299
10300
10301
10302
10303
10304 //=============================================================================
10305 // Q3Polyhedron_GetTriangleData : Quesa API entry point.
10306 //-----------------------------------------------------------------------------
10307 TQ3Status
Q3Polyhedron_GetTriangleData(TQ3GeometryObject polyhedron,TQ3Uns32 triangleIndex,TQ3PolyhedronTriangleData * triangleData)10308 Q3Polyhedron_GetTriangleData(TQ3GeometryObject polyhedron, TQ3Uns32 triangleIndex, TQ3PolyhedronTriangleData *triangleData)
10309 {
10310
10311
10312 // Release build checks
10313 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10314 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), kQ3Failure);
10315
10316
10317
10318 // Debug build checks
10319 #if Q3_DEBUG
10320 if (0) // Further checks on polyhedron
10321 return(kQ3Failure);
10322
10323 if (0) // Further checks on triangleIndex
10324 return(kQ3Failure);
10325
10326 if (0) // Further checks on triangleData
10327 return(kQ3Failure);
10328 #endif
10329
10330
10331
10332 // Call the bottleneck
10333 E3System_Bottleneck();
10334
10335
10336
10337 // Call our implementation
10338 return(E3Polyhedron_GetTriangleData(polyhedron, triangleIndex, triangleData));
10339 }
10340
10341
10342
10343
10344
10345 //=============================================================================
10346 // Q3Polyhedron_SetTriangleData : Quesa API entry point.
10347 //-----------------------------------------------------------------------------
10348 TQ3Status
Q3Polyhedron_SetTriangleData(TQ3GeometryObject polyhedron,TQ3Uns32 triangleIndex,const TQ3PolyhedronTriangleData * triangleData)10349 Q3Polyhedron_SetTriangleData(TQ3GeometryObject polyhedron, TQ3Uns32 triangleIndex, const TQ3PolyhedronTriangleData *triangleData)
10350 {
10351
10352
10353 // Release build checks
10354 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10355 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), kQ3Failure);
10356
10357
10358
10359 // Debug build checks
10360 #if Q3_DEBUG
10361 if (0) // Further checks on polyhedron
10362 return(kQ3Failure);
10363
10364 if (0) // Further checks on triangleIndex
10365 return(kQ3Failure);
10366
10367 if (0) // Further checks on triangleData
10368 return(kQ3Failure);
10369 #endif
10370
10371
10372
10373 // Call the bottleneck
10374 E3System_Bottleneck();
10375
10376
10377
10378 // Call our implementation
10379 return(E3Polyhedron_SetTriangleData(polyhedron, triangleIndex, triangleData));
10380 }
10381
10382
10383
10384
10385
10386 //=============================================================================
10387 // Q3Polyhedron_GetEdgeData : Quesa API entry point.
10388 //-----------------------------------------------------------------------------
10389 TQ3Status
Q3Polyhedron_GetEdgeData(TQ3GeometryObject polyhedron,TQ3Uns32 edgeIndex,TQ3PolyhedronEdgeData * edgeData)10390 Q3Polyhedron_GetEdgeData(TQ3GeometryObject polyhedron, TQ3Uns32 edgeIndex, TQ3PolyhedronEdgeData *edgeData)
10391 {
10392
10393
10394 // Release build checks
10395 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10396 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(edgeData), kQ3Failure);
10397
10398
10399
10400 // Debug build checks
10401 #if Q3_DEBUG
10402 if (0) // Further checks on polyhedron
10403 return(kQ3Failure);
10404
10405 if (0) // Further checks on edgeIndex
10406 return(kQ3Failure);
10407
10408 if (0) // Further checks on edgeData
10409 return(kQ3Failure);
10410 #endif
10411
10412
10413
10414 // Call the bottleneck
10415 E3System_Bottleneck();
10416
10417
10418
10419 // Call our implementation
10420 return(E3Polyhedron_GetEdgeData(polyhedron, edgeIndex, edgeData));
10421 }
10422
10423
10424
10425
10426
10427 //=============================================================================
10428 // Q3Polyhedron_SetEdgeData : Quesa API entry point.
10429 //-----------------------------------------------------------------------------
10430 TQ3Status
Q3Polyhedron_SetEdgeData(TQ3GeometryObject polyhedron,TQ3Uns32 edgeIndex,const TQ3PolyhedronEdgeData * edgeData)10431 Q3Polyhedron_SetEdgeData(TQ3GeometryObject polyhedron, TQ3Uns32 edgeIndex, const TQ3PolyhedronEdgeData *edgeData)
10432 {
10433
10434
10435 // Release build checks
10436 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyhedron ), kQ3Failure);
10437 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(edgeData), kQ3Failure);
10438
10439
10440
10441 // Debug build checks
10442 #if Q3_DEBUG
10443 if (0) // Further checks on polyhedron
10444 return(kQ3Failure);
10445
10446 if (0) // Further checks on edgeIndex
10447 return(kQ3Failure);
10448
10449 if (0) // Further checks on edgeData
10450 return(kQ3Failure);
10451 #endif
10452
10453
10454
10455 // Call the bottleneck
10456 E3System_Bottleneck();
10457
10458
10459
10460 // Call our implementation
10461 return(E3Polyhedron_SetEdgeData(polyhedron, edgeIndex, edgeData));
10462 }
10463
10464
10465
10466
10467
10468 //=============================================================================
10469 // Q3PolyLine_New : Quesa API entry point.
10470 //-----------------------------------------------------------------------------
10471 TQ3GeometryObject
Q3PolyLine_New(const TQ3PolyLineData * polylineData)10472 Q3PolyLine_New(const TQ3PolyLineData *polylineData)
10473 {
10474
10475
10476 // Release build checks
10477 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polylineData), NULL);
10478
10479
10480
10481 // Debug build checks
10482 #if Q3_DEBUG
10483 // Further checks on polylineData
10484 if (polylineData->numVertices < 2)
10485 {
10486 E3ErrorManager_PostError(kQ3ErrorGeometryInsufficientNumberOfPoints, kQ3False);
10487 return(NULL);
10488 }
10489 #endif
10490
10491
10492
10493 // Call the bottleneck
10494 E3System_Bottleneck();
10495
10496
10497
10498 // Call our implementation
10499 return(E3PolyLine_New(polylineData));
10500 }
10501
10502
10503
10504
10505
10506 //=============================================================================
10507 // Q3PolyLine_Submit : Quesa API entry point.
10508 //-----------------------------------------------------------------------------
10509 TQ3Status
Q3PolyLine_Submit(const TQ3PolyLineData * polyLineData,TQ3ViewObject view)10510 Q3PolyLine_Submit(const TQ3PolyLineData *polyLineData, TQ3ViewObject view)
10511 {
10512
10513
10514 // Release build checks
10515 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyLineData), kQ3Failure);
10516 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
10517
10518
10519
10520 // Debug build checks
10521 #if Q3_DEBUG
10522 if (0) // Further checks on polyLineData
10523 return(kQ3Failure);
10524
10525 if (0) // Further checks on view
10526 return(kQ3Failure);
10527 #endif
10528
10529
10530
10531 // Call the bottleneck
10532 E3System_Bottleneck();
10533
10534
10535
10536 // Call our implementation
10537 return(E3PolyLine_Submit(polyLineData, view));
10538 }
10539
10540
10541
10542
10543
10544 //=============================================================================
10545 // Q3PolyLine_SetData : Quesa API entry point.
10546 //-----------------------------------------------------------------------------
10547 TQ3Status
Q3PolyLine_SetData(TQ3GeometryObject polyLine,const TQ3PolyLineData * polyLineData)10548 Q3PolyLine_SetData(TQ3GeometryObject polyLine, const TQ3PolyLineData *polyLineData)
10549 {
10550
10551
10552 // Release build checks
10553 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10554 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyLineData), kQ3Failure);
10555
10556
10557
10558 // Debug build checks
10559 #if Q3_DEBUG
10560 if (0) // Further checks on polyLine
10561 return(kQ3Failure);
10562
10563 // Further checks on polylineData
10564 if (polyLineData->numVertices < 2)
10565 {
10566 E3ErrorManager_PostError(kQ3ErrorGeometryInsufficientNumberOfPoints, kQ3False);
10567 return(kQ3Failure);
10568 }
10569 #endif
10570
10571
10572
10573 // Call the bottleneck
10574 E3System_Bottleneck();
10575
10576
10577
10578 // Call our implementation
10579 return(E3PolyLine_SetData(polyLine, polyLineData));
10580 }
10581
10582
10583
10584
10585
10586 //=============================================================================
10587 // Q3PolyLine_GetData : Quesa API entry point.
10588 //-----------------------------------------------------------------------------
10589 TQ3Status
Q3PolyLine_GetData(TQ3GeometryObject polyLine,TQ3PolyLineData * polyLineData)10590 Q3PolyLine_GetData(TQ3GeometryObject polyLine, TQ3PolyLineData *polyLineData)
10591 {
10592
10593
10594 // Release build checks
10595 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10596 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyLineData), kQ3Failure);
10597
10598
10599
10600 // Debug build checks
10601 #if Q3_DEBUG
10602 if (0) // Further checks on polyLine
10603 return(kQ3Failure);
10604
10605 if (0) // Further checks on polyLineData
10606 return(kQ3Failure);
10607 #endif
10608
10609
10610
10611 // Call the bottleneck
10612 E3System_Bottleneck();
10613
10614
10615
10616 // Call our implementation
10617 return(E3PolyLine_GetData(polyLine, polyLineData));
10618 }
10619
10620
10621
10622
10623
10624 //=============================================================================
10625 // Q3PolyLine_EmptyData : Quesa API entry point.
10626 //-----------------------------------------------------------------------------
10627 TQ3Status
Q3PolyLine_EmptyData(TQ3PolyLineData * polyLineData)10628 Q3PolyLine_EmptyData(TQ3PolyLineData *polyLineData)
10629 {
10630
10631
10632 // Release build checks
10633 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(polyLineData), kQ3Failure);
10634
10635
10636
10637 // Debug build checks
10638 #if Q3_DEBUG
10639 if (0) // Further checks on polyLineData
10640 return(kQ3Failure);
10641 #endif
10642
10643
10644
10645 // Call the bottleneck
10646 E3System_Bottleneck();
10647
10648
10649
10650 // Call our implementation
10651 return(E3PolyLine_EmptyData(polyLineData));
10652 }
10653
10654
10655
10656
10657
10658 //=============================================================================
10659 // Q3PolyLine_GetVertexPosition : Quesa API entry point.
10660 //-----------------------------------------------------------------------------
10661 TQ3Status
Q3PolyLine_GetVertexPosition(TQ3GeometryObject polyLine,TQ3Uns32 index,TQ3Point3D * position)10662 Q3PolyLine_GetVertexPosition(TQ3GeometryObject polyLine, TQ3Uns32 index, TQ3Point3D *position)
10663 {
10664
10665
10666 // Release build checks
10667 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10668 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
10669
10670
10671
10672 // Debug build checks
10673 #if Q3_DEBUG
10674 if (0) // Further checks on polyLine
10675 return(kQ3Failure);
10676
10677 if (0) // Further checks on index
10678 return(kQ3Failure);
10679
10680 if (0) // Further checks on position
10681 return(kQ3Failure);
10682 #endif
10683
10684
10685
10686 // Call the bottleneck
10687 E3System_Bottleneck();
10688
10689
10690
10691 // Call our implementation
10692 return(E3PolyLine_GetVertexPosition(polyLine, index, position));
10693 }
10694
10695
10696
10697
10698
10699 //=============================================================================
10700 // Q3PolyLine_SetVertexPosition : Quesa API entry point.
10701 //-----------------------------------------------------------------------------
10702 TQ3Status
Q3PolyLine_SetVertexPosition(TQ3GeometryObject polyLine,TQ3Uns32 index,const TQ3Point3D * position)10703 Q3PolyLine_SetVertexPosition(TQ3GeometryObject polyLine, TQ3Uns32 index, const TQ3Point3D *position)
10704 {
10705
10706
10707 // Release build checks
10708 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10709 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
10710
10711
10712
10713 // Debug build checks
10714 #if Q3_DEBUG
10715 if (0) // Further checks on polyLine
10716 return(kQ3Failure);
10717
10718 if (0) // Further checks on index
10719 return(kQ3Failure);
10720
10721 if (0) // Further checks on position
10722 return(kQ3Failure);
10723 #endif
10724
10725
10726
10727 // Call the bottleneck
10728 E3System_Bottleneck();
10729
10730
10731
10732 // Call our implementation
10733 return(E3PolyLine_SetVertexPosition(polyLine, index, position));
10734 }
10735
10736
10737
10738
10739
10740 //=============================================================================
10741 // Q3PolyLine_GetVertexAttributeSet : Quesa API entry point.
10742 //-----------------------------------------------------------------------------
10743 TQ3Status
Q3PolyLine_GetVertexAttributeSet(TQ3GeometryObject polyLine,TQ3Uns32 index,TQ3AttributeSet * attributeSet)10744 Q3PolyLine_GetVertexAttributeSet(TQ3GeometryObject polyLine, TQ3Uns32 index, TQ3AttributeSet *attributeSet)
10745 {
10746
10747
10748 // Release build checks
10749 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10750 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
10751
10752
10753
10754 // Debug build checks
10755 #if Q3_DEBUG
10756 if (0) // Further checks on polyLine
10757 return(kQ3Failure);
10758
10759 if (0) // Further checks on index
10760 return(kQ3Failure);
10761
10762 if (0) // Further checks on attributeSet
10763 return(kQ3Failure);
10764 #endif
10765
10766
10767
10768 // Call the bottleneck
10769 E3System_Bottleneck();
10770
10771
10772
10773 // Call our implementation
10774 return(E3PolyLine_GetVertexAttributeSet(polyLine, index, attributeSet));
10775 }
10776
10777
10778
10779
10780
10781 //=============================================================================
10782 // Q3PolyLine_SetVertexAttributeSet : Quesa API entry point.
10783 //-----------------------------------------------------------------------------
10784 TQ3Status
Q3PolyLine_SetVertexAttributeSet(TQ3GeometryObject polyLine,TQ3Uns32 index,TQ3AttributeSet attributeSet)10785 Q3PolyLine_SetVertexAttributeSet(TQ3GeometryObject polyLine, TQ3Uns32 index, TQ3AttributeSet attributeSet)
10786 {
10787
10788
10789 // Release build checks
10790 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10791
10792
10793
10794 // Debug build checks
10795 #if Q3_DEBUG
10796 if (0) // Further checks on polyLine
10797 return(kQ3Failure);
10798
10799 if (0) // Further checks on index
10800 return(kQ3Failure);
10801
10802 if (0) // Further checks on attributeSet
10803 return(kQ3Failure);
10804 #endif
10805
10806
10807
10808 // Call the bottleneck
10809 E3System_Bottleneck();
10810
10811
10812
10813 // Call our implementation
10814 return(E3PolyLine_SetVertexAttributeSet(polyLine, index, attributeSet));
10815 }
10816
10817
10818
10819
10820
10821 //=============================================================================
10822 // Q3PolyLine_GetSegmentAttributeSet : Quesa API entry point.
10823 //-----------------------------------------------------------------------------
10824 TQ3Status
Q3PolyLine_GetSegmentAttributeSet(TQ3GeometryObject polyLine,TQ3Uns32 index,TQ3AttributeSet * attributeSet)10825 Q3PolyLine_GetSegmentAttributeSet(TQ3GeometryObject polyLine, TQ3Uns32 index, TQ3AttributeSet *attributeSet)
10826 {
10827
10828
10829 // Release build checks
10830 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10831 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
10832
10833
10834
10835 // Debug build checks
10836 #if Q3_DEBUG
10837 if (0) // Further checks on polyLine
10838 return(kQ3Failure);
10839
10840 if (0) // Further checks on index
10841 return(kQ3Failure);
10842
10843 if (0) // Further checks on attributeSet
10844 return(kQ3Failure);
10845 #endif
10846
10847
10848
10849 // Call the bottleneck
10850 E3System_Bottleneck();
10851
10852
10853
10854 // Call our implementation
10855 return(E3PolyLine_GetSegmentAttributeSet(polyLine, index, attributeSet));
10856 }
10857
10858
10859
10860
10861
10862 //=============================================================================
10863 // Q3PolyLine_SetSegmentAttributeSet : Quesa API entry point.
10864 //-----------------------------------------------------------------------------
10865 TQ3Status
Q3PolyLine_SetSegmentAttributeSet(TQ3GeometryObject polyLine,TQ3Uns32 index,TQ3AttributeSet attributeSet)10866 Q3PolyLine_SetSegmentAttributeSet(TQ3GeometryObject polyLine, TQ3Uns32 index, TQ3AttributeSet attributeSet)
10867 {
10868
10869
10870 // Release build checks
10871 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( polyLine ), kQ3Failure);
10872
10873
10874
10875 // Debug build checks
10876 #if Q3_DEBUG
10877 if (0) // Further checks on polyLine
10878 return(kQ3Failure);
10879
10880 if (0) // Further checks on index
10881 return(kQ3Failure);
10882
10883 if (0) // Further checks on attributeSet
10884 return(kQ3Failure);
10885 #endif
10886
10887
10888
10889 // Call the bottleneck
10890 E3System_Bottleneck();
10891
10892
10893
10894 // Call our implementation
10895 return(E3PolyLine_SetSegmentAttributeSet(polyLine, index, attributeSet));
10896 }
10897
10898
10899
10900
10901
10902 //=============================================================================
10903 // Q3Torus_New : Quesa API entry point.
10904 //-----------------------------------------------------------------------------
10905 TQ3GeometryObject
Q3Torus_New(const TQ3TorusData * torusData)10906 Q3Torus_New(const TQ3TorusData *torusData)
10907 {
10908
10909
10910 // Release build checks
10911 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(torusData) || (torusData == NULL), NULL);
10912
10913
10914
10915 // Debug build checks
10916 #if Q3_DEBUG
10917 if (0) // Further checks on torusData
10918 return(NULL);
10919 #endif
10920
10921
10922
10923 // Call the bottleneck
10924 E3System_Bottleneck();
10925
10926
10927
10928 // Call our implementation
10929 return(E3Torus_New(torusData));
10930 }
10931
10932
10933
10934
10935
10936 //=============================================================================
10937 // Q3Torus_Submit : Quesa API entry point.
10938 //-----------------------------------------------------------------------------
10939 TQ3Status
Q3Torus_Submit(const TQ3TorusData * torusData,TQ3ViewObject view)10940 Q3Torus_Submit(const TQ3TorusData *torusData, TQ3ViewObject view)
10941 {
10942
10943
10944 // Release build checks
10945 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(torusData), kQ3Failure);
10946 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
10947
10948
10949
10950 // Debug build checks
10951 #if Q3_DEBUG
10952 if (0) // Further checks on torusData
10953 return(kQ3Failure);
10954
10955 if (0) // Further checks on view
10956 return(kQ3Failure);
10957 #endif
10958
10959
10960
10961 // Call the bottleneck
10962 E3System_Bottleneck();
10963
10964
10965
10966 // Call our implementation
10967 return(E3Torus_Submit(torusData, view));
10968 }
10969
10970
10971
10972
10973
10974 //=============================================================================
10975 // Q3Torus_SetData : Quesa API entry point.
10976 //-----------------------------------------------------------------------------
10977 TQ3Status
Q3Torus_SetData(TQ3GeometryObject torus,const TQ3TorusData * torusData)10978 Q3Torus_SetData(TQ3GeometryObject torus, const TQ3TorusData *torusData)
10979 {
10980
10981
10982 // Release build checks
10983 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
10984 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(torusData), kQ3Failure);
10985
10986
10987
10988 // Debug build checks
10989 #if Q3_DEBUG
10990 if (0) // Further checks on torus
10991 return(kQ3Failure);
10992
10993 if (0) // Further checks on torusData
10994 return(kQ3Failure);
10995 #endif
10996
10997
10998
10999 // Call the bottleneck
11000 E3System_Bottleneck();
11001
11002
11003
11004 // Call our implementation
11005 return(E3Torus_SetData(torus, torusData));
11006 }
11007
11008
11009
11010
11011
11012 //=============================================================================
11013 // Q3Torus_GetData : Quesa API entry point.
11014 //-----------------------------------------------------------------------------
11015 TQ3Status
Q3Torus_GetData(TQ3GeometryObject torus,TQ3TorusData * torusData)11016 Q3Torus_GetData(TQ3GeometryObject torus, TQ3TorusData *torusData)
11017 {
11018
11019
11020 // Release build checks
11021 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11022 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(torusData), kQ3Failure);
11023
11024
11025
11026 // Debug build checks
11027 #if Q3_DEBUG
11028 if (0) // Further checks on torus
11029 return(kQ3Failure);
11030
11031 if (0) // Further checks on torusData
11032 return(kQ3Failure);
11033 #endif
11034
11035
11036
11037 // Call the bottleneck
11038 E3System_Bottleneck();
11039
11040
11041
11042 // Call our implementation
11043 return(E3Torus_GetData(torus, torusData));
11044 }
11045
11046
11047
11048
11049
11050 //=============================================================================
11051 // Q3Torus_SetOrigin : Quesa API entry point.
11052 //-----------------------------------------------------------------------------
11053 TQ3Status
Q3Torus_SetOrigin(TQ3GeometryObject torus,const TQ3Point3D * origin)11054 Q3Torus_SetOrigin(TQ3GeometryObject torus, const TQ3Point3D *origin)
11055 {
11056
11057
11058 // Release build checks
11059 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11060 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
11061
11062
11063
11064 // Debug build checks
11065 #if Q3_DEBUG
11066 if (0) // Further checks on torus
11067 return(kQ3Failure);
11068
11069 if (0) // Further checks on origin
11070 return(kQ3Failure);
11071 #endif
11072
11073
11074
11075 // Call the bottleneck
11076 E3System_Bottleneck();
11077
11078
11079
11080 // Call our implementation
11081 return(E3Torus_SetOrigin(torus, origin));
11082 }
11083
11084
11085
11086
11087
11088 //=============================================================================
11089 // Q3Torus_SetOrientation : Quesa API entry point.
11090 //-----------------------------------------------------------------------------
11091 TQ3Status
Q3Torus_SetOrientation(TQ3GeometryObject torus,const TQ3Vector3D * orientation)11092 Q3Torus_SetOrientation(TQ3GeometryObject torus, const TQ3Vector3D *orientation)
11093 {
11094
11095
11096 // Release build checks
11097 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11098 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
11099
11100
11101
11102 // Debug build checks
11103 #if Q3_DEBUG
11104 if (0) // Further checks on torus
11105 return(kQ3Failure);
11106
11107 if (0) // Further checks on orientation
11108 return(kQ3Failure);
11109 #endif
11110
11111
11112
11113 // Call the bottleneck
11114 E3System_Bottleneck();
11115
11116
11117
11118 // Call our implementation
11119 return(E3Torus_SetOrientation(torus, orientation));
11120 }
11121
11122
11123
11124
11125
11126 //=============================================================================
11127 // Q3Torus_SetMajorRadius : Quesa API entry point.
11128 //-----------------------------------------------------------------------------
11129 TQ3Status
Q3Torus_SetMajorRadius(TQ3GeometryObject torus,const TQ3Vector3D * majorRadius)11130 Q3Torus_SetMajorRadius(TQ3GeometryObject torus, const TQ3Vector3D *majorRadius)
11131 {
11132
11133
11134 // Release build checks
11135 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11136 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
11137
11138
11139
11140 // Debug build checks
11141 #if Q3_DEBUG
11142 if (0) // Further checks on torus
11143 return(kQ3Failure);
11144
11145 if (0) // Further checks on majorRadius
11146 return(kQ3Failure);
11147 #endif
11148
11149
11150
11151 // Call the bottleneck
11152 E3System_Bottleneck();
11153
11154
11155
11156 // Call our implementation
11157 return(E3Torus_SetMajorRadius(torus, majorRadius));
11158 }
11159
11160
11161
11162
11163
11164 //=============================================================================
11165 // Q3Torus_SetMinorRadius : Quesa API entry point.
11166 //-----------------------------------------------------------------------------
11167 TQ3Status
Q3Torus_SetMinorRadius(TQ3GeometryObject torus,const TQ3Vector3D * minorRadius)11168 Q3Torus_SetMinorRadius(TQ3GeometryObject torus, const TQ3Vector3D *minorRadius)
11169 {
11170
11171
11172 // Release build checks
11173 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11174 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
11175
11176
11177
11178 // Debug build checks
11179 #if Q3_DEBUG
11180 if (0) // Further checks on torus
11181 return(kQ3Failure);
11182
11183 if (0) // Further checks on minorRadius
11184 return(kQ3Failure);
11185 #endif
11186
11187
11188
11189 // Call the bottleneck
11190 E3System_Bottleneck();
11191
11192
11193
11194 // Call our implementation
11195 return(E3Torus_SetMinorRadius(torus, minorRadius));
11196 }
11197
11198
11199
11200
11201
11202 //=============================================================================
11203 // Q3Torus_SetRatio : Quesa API entry point.
11204 //-----------------------------------------------------------------------------
11205 TQ3Status
Q3Torus_SetRatio(TQ3GeometryObject torus,float ratio)11206 Q3Torus_SetRatio(TQ3GeometryObject torus, float ratio)
11207 {
11208
11209
11210 // Release build checks
11211 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11212
11213
11214
11215 // Debug build checks
11216 #if Q3_DEBUG
11217 if (0) // Further checks on torus
11218 return(kQ3Failure);
11219
11220 if (0) // Further checks on ratio
11221 return(kQ3Failure);
11222 #endif
11223
11224
11225
11226 // Call the bottleneck
11227 E3System_Bottleneck();
11228
11229
11230
11231 // Call our implementation
11232 return(E3Torus_SetRatio(torus, ratio));
11233 }
11234
11235
11236
11237
11238
11239 //=============================================================================
11240 // Q3Torus_GetOrigin : Quesa API entry point.
11241 //-----------------------------------------------------------------------------
11242 TQ3Status
Q3Torus_GetOrigin(TQ3GeometryObject torus,TQ3Point3D * origin)11243 Q3Torus_GetOrigin(TQ3GeometryObject torus, TQ3Point3D *origin)
11244 {
11245
11246
11247 // Release build checks
11248 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11249 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(origin), kQ3Failure);
11250
11251
11252
11253 // Debug build checks
11254 #if Q3_DEBUG
11255 if (0) // Further checks on torus
11256 return(kQ3Failure);
11257
11258 if (0) // Further checks on origin
11259 return(kQ3Failure);
11260 #endif
11261
11262
11263
11264 // Call the bottleneck
11265 E3System_Bottleneck();
11266
11267
11268
11269 // Call our implementation
11270 return(E3Torus_GetOrigin(torus, origin));
11271 }
11272
11273
11274
11275
11276
11277 //=============================================================================
11278 // Q3Torus_GetOrientation : Quesa API entry point.
11279 //-----------------------------------------------------------------------------
11280 TQ3Status
Q3Torus_GetOrientation(TQ3GeometryObject torus,TQ3Vector3D * orientation)11281 Q3Torus_GetOrientation(TQ3GeometryObject torus, TQ3Vector3D *orientation)
11282 {
11283
11284
11285 // Release build checks
11286 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11287 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(orientation), kQ3Failure);
11288
11289
11290
11291 // Debug build checks
11292 #if Q3_DEBUG
11293 if (0) // Further checks on torus
11294 return(kQ3Failure);
11295
11296 if (0) // Further checks on orientation
11297 return(kQ3Failure);
11298 #endif
11299
11300
11301
11302 // Call the bottleneck
11303 E3System_Bottleneck();
11304
11305
11306
11307 // Call our implementation
11308 return(E3Torus_GetOrientation(torus, orientation));
11309 }
11310
11311
11312
11313
11314
11315 //=============================================================================
11316 // Q3Torus_GetMajorRadius : Quesa API entry point.
11317 //-----------------------------------------------------------------------------
11318 TQ3Status
Q3Torus_GetMajorRadius(TQ3GeometryObject torus,TQ3Vector3D * majorRadius)11319 Q3Torus_GetMajorRadius(TQ3GeometryObject torus, TQ3Vector3D *majorRadius)
11320 {
11321
11322
11323 // Release build checks
11324 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11325 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(majorRadius), kQ3Failure);
11326
11327
11328
11329 // Debug build checks
11330 #if Q3_DEBUG
11331 if (0) // Further checks on torus
11332 return(kQ3Failure);
11333
11334 if (0) // Further checks on majorRadius
11335 return(kQ3Failure);
11336 #endif
11337
11338
11339
11340 // Call the bottleneck
11341 E3System_Bottleneck();
11342
11343
11344
11345 // Call our implementation
11346 return(E3Torus_GetMajorRadius(torus, majorRadius));
11347 }
11348
11349
11350
11351
11352
11353 //=============================================================================
11354 // Q3Torus_GetMinorRadius : Quesa API entry point.
11355 //-----------------------------------------------------------------------------
11356 TQ3Status
Q3Torus_GetMinorRadius(TQ3GeometryObject torus,TQ3Vector3D * minorRadius)11357 Q3Torus_GetMinorRadius(TQ3GeometryObject torus, TQ3Vector3D *minorRadius)
11358 {
11359
11360
11361 // Release build checks
11362 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11363 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(minorRadius), kQ3Failure);
11364
11365
11366
11367 // Debug build checks
11368 #if Q3_DEBUG
11369 if (0) // Further checks on torus
11370 return(kQ3Failure);
11371
11372 if (0) // Further checks on minorRadius
11373 return(kQ3Failure);
11374 #endif
11375
11376
11377
11378 // Call the bottleneck
11379 E3System_Bottleneck();
11380
11381
11382
11383 // Call our implementation
11384 return(E3Torus_GetMinorRadius(torus, minorRadius));
11385 }
11386
11387
11388
11389
11390
11391 //=============================================================================
11392 // Q3Torus_GetRatio : Quesa API entry point.
11393 //-----------------------------------------------------------------------------
11394 TQ3Status
Q3Torus_GetRatio(TQ3GeometryObject torus,float * ratio)11395 Q3Torus_GetRatio(TQ3GeometryObject torus, float *ratio)
11396 {
11397
11398
11399 // Release build checks
11400 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( torus ), kQ3Failure);
11401 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ratio), kQ3Failure);
11402
11403
11404
11405 // Debug build checks
11406 #if Q3_DEBUG
11407 if (0) // Further checks on torus
11408 return(kQ3Failure);
11409
11410 if (0) // Further checks on ratio
11411 return(kQ3Failure);
11412 #endif
11413
11414
11415
11416 // Call the bottleneck
11417 E3System_Bottleneck();
11418
11419
11420
11421 // Call our implementation
11422 return(E3Torus_GetRatio(torus, ratio));
11423 }
11424
11425
11426
11427
11428
11429 //=============================================================================
11430 // Q3Torus_EmptyData : Quesa API entry point.
11431 //-----------------------------------------------------------------------------
11432 TQ3Status
Q3Torus_EmptyData(TQ3TorusData * torusData)11433 Q3Torus_EmptyData(TQ3TorusData *torusData)
11434 {
11435
11436
11437 // Release build checks
11438 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(torusData), kQ3Failure);
11439
11440
11441
11442 // Debug build checks
11443 #if Q3_DEBUG
11444 if (0) // Further checks on torusData
11445 return(kQ3Failure);
11446 #endif
11447
11448
11449
11450 // Call the bottleneck
11451 E3System_Bottleneck();
11452
11453
11454
11455 // Call our implementation
11456 return(E3Torus_EmptyData(torusData));
11457 }
11458
11459
11460
11461
11462
11463 //=============================================================================
11464 // Q3Triangle_New : Quesa API entry point.
11465 //-----------------------------------------------------------------------------
11466 TQ3GeometryObject
Q3Triangle_New(const TQ3TriangleData * triangleData)11467 Q3Triangle_New(const TQ3TriangleData *triangleData)
11468 {
11469
11470
11471 // Release build checks
11472 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), NULL);
11473
11474
11475
11476 // Debug build checks
11477 #if Q3_DEBUG
11478 if (0) // Further checks on triangleData
11479 return(NULL);
11480 #endif
11481
11482
11483
11484 // Call the bottleneck
11485 E3System_Bottleneck();
11486
11487
11488
11489 // Call our implementation
11490 return(E3Triangle_New(triangleData));
11491 }
11492
11493
11494
11495
11496
11497 //=============================================================================
11498 // Q3Triangle_Submit : Quesa API entry point.
11499 //-----------------------------------------------------------------------------
11500 TQ3Status
Q3Triangle_Submit(const TQ3TriangleData * triangleData,TQ3ViewObject view)11501 Q3Triangle_Submit(const TQ3TriangleData *triangleData, TQ3ViewObject view)
11502 {
11503
11504
11505 // Release build checks
11506 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), kQ3Failure);
11507 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
11508
11509
11510
11511 // Debug build checks
11512 #if Q3_DEBUG
11513 if (0) // Further checks on triangleData
11514 return(kQ3Failure);
11515
11516 if (0) // Further checks on view
11517 return(kQ3Failure);
11518 #endif
11519
11520
11521
11522 // Call the bottleneck
11523 E3System_Bottleneck();
11524
11525
11526
11527 // Call our implementation
11528 return(E3Triangle_Submit(triangleData, view));
11529 }
11530
11531
11532
11533
11534
11535 //=============================================================================
11536 // Q3Triangle_SetData : Quesa API entry point.
11537 //-----------------------------------------------------------------------------
11538 TQ3Status
Q3Triangle_SetData(TQ3GeometryObject triangle,const TQ3TriangleData * triangleData)11539 Q3Triangle_SetData(TQ3GeometryObject triangle, const TQ3TriangleData *triangleData)
11540 {
11541
11542
11543 // Release build checks
11544 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triangle ), kQ3Failure);
11545 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), kQ3Failure);
11546
11547
11548
11549 // Debug build checks
11550 #if Q3_DEBUG
11551 if (0) // Further checks on triangle
11552 return(kQ3Failure);
11553
11554 if (0) // Further checks on triangleData
11555 return(kQ3Failure);
11556 #endif
11557
11558
11559
11560 // Call the bottleneck
11561 E3System_Bottleneck();
11562
11563
11564
11565 // Call our implementation
11566 return(E3Triangle_SetData(triangle, triangleData));
11567 }
11568
11569
11570
11571
11572
11573 //=============================================================================
11574 // Q3Triangle_GetData : Quesa API entry point.
11575 //-----------------------------------------------------------------------------
11576 TQ3Status
Q3Triangle_GetData(TQ3GeometryObject triangle,TQ3TriangleData * triangleData)11577 Q3Triangle_GetData(TQ3GeometryObject triangle, TQ3TriangleData *triangleData)
11578 {
11579
11580
11581 // Release build checks
11582 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triangle ), kQ3Failure);
11583 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), kQ3Failure);
11584
11585
11586
11587 // Debug build checks
11588 #if Q3_DEBUG
11589 if (0) // Further checks on triangle
11590 return(kQ3Failure);
11591
11592 if (0) // Further checks on triangleData
11593 return(kQ3Failure);
11594 #endif
11595
11596
11597
11598 // Call the bottleneck
11599 E3System_Bottleneck();
11600
11601
11602
11603 // Call our implementation
11604 return(E3Triangle_GetData(triangle, triangleData));
11605 }
11606
11607
11608
11609
11610
11611 //=============================================================================
11612 // Q3Triangle_EmptyData : Quesa API entry point.
11613 //-----------------------------------------------------------------------------
11614 TQ3Status
Q3Triangle_EmptyData(TQ3TriangleData * triangleData)11615 Q3Triangle_EmptyData(TQ3TriangleData *triangleData)
11616 {
11617
11618
11619 // Release build checks
11620 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triangleData), kQ3Failure);
11621
11622
11623
11624 // Debug build checks
11625 #if Q3_DEBUG
11626 if (0) // Further checks on triangleData
11627 return(kQ3Failure);
11628 #endif
11629
11630
11631
11632 // Call the bottleneck
11633 E3System_Bottleneck();
11634
11635
11636
11637 // Call our implementation
11638 return(E3Triangle_EmptyData(triangleData));
11639 }
11640
11641
11642
11643
11644
11645 //=============================================================================
11646 // Q3Triangle_GetVertexPosition : Quesa API entry point.
11647 //-----------------------------------------------------------------------------
11648 TQ3Status
Q3Triangle_GetVertexPosition(TQ3GeometryObject triangle,TQ3Uns32 index,TQ3Point3D * point)11649 Q3Triangle_GetVertexPosition(TQ3GeometryObject triangle, TQ3Uns32 index, TQ3Point3D *point)
11650 {
11651
11652
11653 // Release build checks
11654 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triangle ), kQ3Failure);
11655 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point), kQ3Failure);
11656
11657
11658
11659 // Debug build checks
11660 #if Q3_DEBUG
11661 if (0) // Further checks on triangle
11662 return(kQ3Failure);
11663
11664 // Further checks on index
11665 if (index >= 3)
11666 {
11667 E3ErrorManager_PostError(kQ3ErrorParameterOutOfRange, kQ3False);
11668 return(kQ3Failure);
11669 }
11670
11671 if (0) // Further checks on point
11672 return(kQ3Failure);
11673 #endif
11674
11675
11676
11677 // Call the bottleneck
11678 E3System_Bottleneck();
11679
11680
11681
11682 // Call our implementation
11683 return(E3Triangle_GetVertexPosition(triangle, index, point));
11684 }
11685
11686
11687
11688
11689
11690 //=============================================================================
11691 // Q3Triangle_SetVertexPosition : Quesa API entry point.
11692 //-----------------------------------------------------------------------------
11693 TQ3Status
Q3Triangle_SetVertexPosition(TQ3GeometryObject triangle,TQ3Uns32 index,const TQ3Point3D * point)11694 Q3Triangle_SetVertexPosition(TQ3GeometryObject triangle, TQ3Uns32 index, const TQ3Point3D *point)
11695 {
11696
11697
11698 // Release build checks
11699 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triangle ), kQ3Failure);
11700 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point), kQ3Failure);
11701
11702
11703
11704 // Debug build checks
11705 #if Q3_DEBUG
11706 if (0) // Further checks on triangle
11707 return(kQ3Failure);
11708
11709 // Further checks on index
11710 if (index >= 3)
11711 {
11712 E3ErrorManager_PostError(kQ3ErrorParameterOutOfRange, kQ3False);
11713 return(kQ3Failure);
11714 }
11715
11716 if (0) // Further checks on point
11717 return(kQ3Failure);
11718 #endif
11719
11720
11721
11722 // Call the bottleneck
11723 E3System_Bottleneck();
11724
11725
11726
11727 // Call our implementation
11728 return(E3Triangle_SetVertexPosition(triangle, index, point));
11729 }
11730
11731
11732
11733
11734
11735 //=============================================================================
11736 // Q3Triangle_GetVertexAttributeSet : Quesa API entry point.
11737 //-----------------------------------------------------------------------------
11738 TQ3Status
Q3Triangle_GetVertexAttributeSet(TQ3GeometryObject triangle,TQ3Uns32 index,TQ3AttributeSet * attributeSet)11739 Q3Triangle_GetVertexAttributeSet(TQ3GeometryObject triangle, TQ3Uns32 index, TQ3AttributeSet *attributeSet)
11740 {
11741
11742
11743 // Release build checks
11744 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triangle ), kQ3Failure);
11745 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
11746
11747
11748
11749 // Debug build checks
11750 #if Q3_DEBUG
11751 if (0) // Further checks on triangle
11752 return(kQ3Failure);
11753
11754 // Further checks on index
11755 if (index >= 3)
11756 {
11757 E3ErrorManager_PostError(kQ3ErrorParameterOutOfRange, kQ3False);
11758 return(kQ3Failure);
11759 }
11760
11761 if (0) // Further checks on attributeSet
11762 return(kQ3Failure);
11763 #endif
11764
11765
11766
11767 // Call the bottleneck
11768 E3System_Bottleneck();
11769
11770
11771
11772 // Call our implementation
11773 return(E3Triangle_GetVertexAttributeSet(triangle, index, attributeSet));
11774 }
11775
11776
11777
11778
11779
11780 //=============================================================================
11781 // Q3Triangle_SetVertexAttributeSet : Quesa API entry point.
11782 //-----------------------------------------------------------------------------
11783 TQ3Status
Q3Triangle_SetVertexAttributeSet(TQ3GeometryObject triangle,TQ3Uns32 index,TQ3AttributeSet attributeSet)11784 Q3Triangle_SetVertexAttributeSet(TQ3GeometryObject triangle, TQ3Uns32 index, TQ3AttributeSet attributeSet)
11785 {
11786
11787
11788 // Release build checks
11789 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triangle ), kQ3Failure);
11790
11791
11792
11793 // Debug build checks
11794 #if Q3_DEBUG
11795 if (0) // Further checks on triangle
11796 return(kQ3Failure);
11797
11798 // Further checks on index
11799 if (index >= 3)
11800 {
11801 E3ErrorManager_PostError(kQ3ErrorParameterOutOfRange, kQ3False);
11802 return(kQ3Failure);
11803 }
11804
11805 if (0) // Further checks on attributeSet
11806 return(kQ3Failure);
11807 #endif
11808
11809
11810
11811 // Call the bottleneck
11812 E3System_Bottleneck();
11813
11814
11815
11816 // Call our implementation
11817 return(E3Triangle_SetVertexAttributeSet(triangle, index, attributeSet));
11818 }
11819
11820
11821
11822
11823
11824 //=============================================================================
11825 // Q3TriGrid_New : Quesa API entry point.
11826 //-----------------------------------------------------------------------------
11827 TQ3GeometryObject
Q3TriGrid_New(const TQ3TriGridData * triGridData)11828 Q3TriGrid_New(const TQ3TriGridData *triGridData)
11829 {
11830
11831
11832 // Release build checks
11833 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triGridData), NULL);
11834
11835
11836
11837 // Debug build checks
11838 #if Q3_DEBUG
11839 if (0) // Further checks on triGridData
11840 return(NULL);
11841 #endif
11842
11843
11844
11845 // Call the bottleneck
11846 E3System_Bottleneck();
11847
11848
11849
11850 // Call our implementation
11851 return(E3TriGrid_New(triGridData));
11852 }
11853
11854
11855
11856
11857
11858 //=============================================================================
11859 // Q3TriGrid_Submit : Quesa API entry point.
11860 //-----------------------------------------------------------------------------
11861 TQ3Status
Q3TriGrid_Submit(const TQ3TriGridData * triGridData,TQ3ViewObject view)11862 Q3TriGrid_Submit(const TQ3TriGridData *triGridData, TQ3ViewObject view)
11863 {
11864
11865
11866 // Release build checks
11867 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triGridData), kQ3Failure);
11868 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
11869
11870
11871
11872 // Debug build checks
11873 #if Q3_DEBUG
11874 if (0) // Further checks on triGridData
11875 return(kQ3Failure);
11876
11877 if (0) // Further checks on view
11878 return(kQ3Failure);
11879 #endif
11880
11881
11882
11883 // Call the bottleneck
11884 E3System_Bottleneck();
11885
11886
11887
11888 // Call our implementation
11889 return(E3TriGrid_Submit(triGridData, view));
11890 }
11891
11892
11893
11894
11895
11896 //=============================================================================
11897 // Q3TriGrid_SetData : Quesa API entry point.
11898 //-----------------------------------------------------------------------------
11899 TQ3Status
Q3TriGrid_SetData(TQ3GeometryObject triGrid,const TQ3TriGridData * triGridData)11900 Q3TriGrid_SetData(TQ3GeometryObject triGrid, const TQ3TriGridData *triGridData)
11901 {
11902
11903
11904 // Release build checks
11905 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
11906 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triGridData), kQ3Failure);
11907
11908
11909
11910 // Debug build checks
11911 #if Q3_DEBUG
11912 if (0) // Further checks on triGrid
11913 return(kQ3Failure);
11914
11915 if (0) // Further checks on triGridData
11916 return(kQ3Failure);
11917 #endif
11918
11919
11920
11921 // Call the bottleneck
11922 E3System_Bottleneck();
11923
11924
11925
11926 // Call our implementation
11927 return(E3TriGrid_SetData(triGrid, triGridData));
11928 }
11929
11930
11931
11932
11933
11934 //=============================================================================
11935 // Q3TriGrid_GetData : Quesa API entry point.
11936 //-----------------------------------------------------------------------------
11937 TQ3Status
Q3TriGrid_GetData(TQ3GeometryObject triGrid,TQ3TriGridData * triGridData)11938 Q3TriGrid_GetData(TQ3GeometryObject triGrid, TQ3TriGridData *triGridData)
11939 {
11940
11941
11942 // Release build checks
11943 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
11944 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triGridData), kQ3Failure);
11945
11946
11947
11948 // Debug build checks
11949 #if Q3_DEBUG
11950 if (0) // Further checks on triGrid
11951 return(kQ3Failure);
11952
11953 if (0) // Further checks on triGridData
11954 return(kQ3Failure);
11955 #endif
11956
11957
11958
11959 // Call the bottleneck
11960 E3System_Bottleneck();
11961
11962
11963
11964 // Call our implementation
11965 return(E3TriGrid_GetData(triGrid, triGridData));
11966 }
11967
11968
11969
11970
11971
11972 //=============================================================================
11973 // Q3TriGrid_EmptyData : Quesa API entry point.
11974 //-----------------------------------------------------------------------------
11975 TQ3Status
Q3TriGrid_EmptyData(TQ3TriGridData * triGridData)11976 Q3TriGrid_EmptyData(TQ3TriGridData *triGridData)
11977 {
11978
11979
11980 // Release build checks
11981 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triGridData), kQ3Failure);
11982
11983
11984
11985 // Debug build checks
11986 #if Q3_DEBUG
11987 if (0) // Further checks on triGridData
11988 return(kQ3Failure);
11989 #endif
11990
11991
11992
11993 // Call the bottleneck
11994 E3System_Bottleneck();
11995
11996
11997
11998 // Call our implementation
11999 return(E3TriGrid_EmptyData(triGridData));
12000 }
12001
12002
12003
12004
12005
12006 //=============================================================================
12007 // Q3TriGrid_GetVertexPosition : Quesa API entry point.
12008 //-----------------------------------------------------------------------------
12009 TQ3Status
Q3TriGrid_GetVertexPosition(TQ3GeometryObject triGrid,TQ3Uns32 rowIndex,TQ3Uns32 columnIndex,TQ3Point3D * position)12010 Q3TriGrid_GetVertexPosition(TQ3GeometryObject triGrid, TQ3Uns32 rowIndex, TQ3Uns32 columnIndex, TQ3Point3D *position)
12011 {
12012
12013
12014 // Release build checks
12015 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
12016 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
12017
12018
12019
12020 // Debug build checks
12021 #if Q3_DEBUG
12022 if (0) // Further checks on triGrid
12023 return(kQ3Failure);
12024
12025 if (0) // Further checks on rowIndex
12026 return(kQ3Failure);
12027
12028 if (0) // Further checks on columnIndex
12029 return(kQ3Failure);
12030
12031 if (0) // Further checks on position
12032 return(kQ3Failure);
12033 #endif
12034
12035
12036
12037 // Call the bottleneck
12038 E3System_Bottleneck();
12039
12040
12041
12042 // Call our implementation
12043 return(E3TriGrid_GetVertexPosition(triGrid, rowIndex, columnIndex, position));
12044 }
12045
12046
12047
12048
12049
12050 //=============================================================================
12051 // Q3TriGrid_SetVertexPosition : Quesa API entry point.
12052 //-----------------------------------------------------------------------------
12053 TQ3Status
Q3TriGrid_SetVertexPosition(TQ3GeometryObject triGrid,TQ3Uns32 rowIndex,TQ3Uns32 columnIndex,const TQ3Point3D * position)12054 Q3TriGrid_SetVertexPosition(TQ3GeometryObject triGrid, TQ3Uns32 rowIndex, TQ3Uns32 columnIndex, const TQ3Point3D *position)
12055 {
12056
12057
12058 // Release build checks
12059 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
12060 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(position), kQ3Failure);
12061
12062
12063
12064 // Debug build checks
12065 #if Q3_DEBUG
12066 if (0) // Further checks on triGrid
12067 return(kQ3Failure);
12068
12069 if (0) // Further checks on rowIndex
12070 return(kQ3Failure);
12071
12072 if (0) // Further checks on columnIndex
12073 return(kQ3Failure);
12074
12075 if (0) // Further checks on position
12076 return(kQ3Failure);
12077 #endif
12078
12079
12080
12081 // Call the bottleneck
12082 E3System_Bottleneck();
12083
12084
12085
12086 // Call our implementation
12087 return(E3TriGrid_SetVertexPosition(triGrid, rowIndex, columnIndex, position));
12088 }
12089
12090
12091
12092
12093
12094 //=============================================================================
12095 // Q3TriGrid_GetVertexAttributeSet : Quesa API entry point.
12096 //-----------------------------------------------------------------------------
12097 TQ3Status
Q3TriGrid_GetVertexAttributeSet(TQ3GeometryObject triGrid,TQ3Uns32 rowIndex,TQ3Uns32 columnIndex,TQ3AttributeSet * attributeSet)12098 Q3TriGrid_GetVertexAttributeSet(TQ3GeometryObject triGrid, TQ3Uns32 rowIndex, TQ3Uns32 columnIndex, TQ3AttributeSet *attributeSet)
12099 {
12100
12101
12102 // Release build checks
12103 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
12104 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
12105
12106
12107
12108 // Debug build checks
12109 #if Q3_DEBUG
12110 if (0) // Further checks on triGrid
12111 return(kQ3Failure);
12112
12113 if (0) // Further checks on rowIndex
12114 return(kQ3Failure);
12115
12116 if (0) // Further checks on columnIndex
12117 return(kQ3Failure);
12118
12119 if (0) // Further checks on attributeSet
12120 return(kQ3Failure);
12121 #endif
12122
12123
12124
12125 // Call the bottleneck
12126 E3System_Bottleneck();
12127
12128
12129
12130 // Call our implementation
12131 return(E3TriGrid_GetVertexAttributeSet(triGrid, rowIndex, columnIndex, attributeSet));
12132 }
12133
12134
12135
12136
12137
12138 //=============================================================================
12139 // Q3TriGrid_SetVertexAttributeSet : Quesa API entry point.
12140 //-----------------------------------------------------------------------------
12141 TQ3Status
Q3TriGrid_SetVertexAttributeSet(TQ3GeometryObject triGrid,TQ3Uns32 rowIndex,TQ3Uns32 columnIndex,TQ3AttributeSet attributeSet)12142 Q3TriGrid_SetVertexAttributeSet(TQ3GeometryObject triGrid, TQ3Uns32 rowIndex, TQ3Uns32 columnIndex, TQ3AttributeSet attributeSet)
12143 {
12144
12145
12146 // Release build checks
12147 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
12148
12149
12150
12151 // Debug build checks
12152 #if Q3_DEBUG
12153 if (0) // Further checks on triGrid
12154 return(kQ3Failure);
12155
12156 if (0) // Further checks on rowIndex
12157 return(kQ3Failure);
12158
12159 if (0) // Further checks on columnIndex
12160 return(kQ3Failure);
12161
12162 if (0) // Further checks on attributeSet
12163 return(kQ3Failure);
12164 #endif
12165
12166
12167
12168 // Call the bottleneck
12169 E3System_Bottleneck();
12170
12171
12172
12173 // Call our implementation
12174 return(E3TriGrid_SetVertexAttributeSet(triGrid, rowIndex, columnIndex, attributeSet));
12175 }
12176
12177
12178
12179
12180
12181 //=============================================================================
12182 // Q3TriGrid_GetFacetAttributeSet : Quesa API entry point.
12183 //-----------------------------------------------------------------------------
12184 TQ3Status
Q3TriGrid_GetFacetAttributeSet(TQ3GeometryObject triGrid,TQ3Uns32 faceIndex,TQ3AttributeSet * facetAttributeSet)12185 Q3TriGrid_GetFacetAttributeSet(TQ3GeometryObject triGrid, TQ3Uns32 faceIndex, TQ3AttributeSet *facetAttributeSet)
12186 {
12187
12188
12189 // Release build checks
12190 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
12191 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(facetAttributeSet), kQ3Failure);
12192
12193
12194
12195 // Debug build checks
12196 #if Q3_DEBUG
12197 if (0) // Further checks on triGrid
12198 return(kQ3Failure);
12199
12200 if (0) // Further checks on faceIndex
12201 return(kQ3Failure);
12202
12203 if (0) // Further checks on facetAttributeSet
12204 return(kQ3Failure);
12205 #endif
12206
12207
12208
12209 // Call the bottleneck
12210 E3System_Bottleneck();
12211
12212
12213
12214 // Call our implementation
12215 return(E3TriGrid_GetFacetAttributeSet(triGrid, faceIndex, facetAttributeSet));
12216 }
12217
12218
12219
12220
12221
12222 //=============================================================================
12223 // Q3TriGrid_SetFacetAttributeSet : Quesa API entry point.
12224 //-----------------------------------------------------------------------------
12225 TQ3Status
Q3TriGrid_SetFacetAttributeSet(TQ3GeometryObject triGrid,TQ3Uns32 faceIndex,TQ3AttributeSet facetAttributeSet)12226 Q3TriGrid_SetFacetAttributeSet(TQ3GeometryObject triGrid, TQ3Uns32 faceIndex, TQ3AttributeSet facetAttributeSet)
12227 {
12228
12229
12230 // Release build checks
12231 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triGrid ), kQ3Failure);
12232
12233
12234
12235 // Debug build checks
12236 #if Q3_DEBUG
12237 if (0) // Further checks on triGrid
12238 return(kQ3Failure);
12239
12240 if (0) // Further checks on faceIndex
12241 return(kQ3Failure);
12242
12243 if (0) // Further checks on facetAttributeSet
12244 return(kQ3Failure);
12245 #endif
12246
12247
12248
12249 // Call the bottleneck
12250 E3System_Bottleneck();
12251
12252
12253
12254 // Call our implementation
12255 return(E3TriGrid_SetFacetAttributeSet(triGrid, faceIndex, facetAttributeSet));
12256 }
12257
12258
12259
12260
12261
12262 //=============================================================================
12263 // Q3TriMesh_New : Quesa API entry point.
12264 //-----------------------------------------------------------------------------
12265 TQ3GeometryObject
Q3TriMesh_New(const TQ3TriMeshData * triMeshData)12266 Q3TriMesh_New(const TQ3TriMeshData *triMeshData)
12267 {
12268
12269
12270 // Release build checks
12271 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triMeshData), NULL);
12272
12273
12274
12275 // Debug build checks
12276 #if Q3_DEBUG
12277 if (0) // Further checks on triMeshData
12278 return(NULL);
12279 #endif
12280
12281
12282
12283 // Call the bottleneck
12284 E3System_Bottleneck();
12285
12286
12287
12288 // Call our implementation
12289 return(E3TriMesh_New(triMeshData));
12290 }
12291
12292
12293
12294
12295
12296 //=============================================================================
12297 // Q3TriMesh_Submit : Quesa API entry point.
12298 //-----------------------------------------------------------------------------
12299 TQ3Status
Q3TriMesh_Submit(const TQ3TriMeshData * triMeshData,TQ3ViewObject view)12300 Q3TriMesh_Submit(const TQ3TriMeshData *triMeshData, TQ3ViewObject view)
12301 {
12302
12303
12304 // Release build checks
12305 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triMeshData), kQ3Failure);
12306 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
12307
12308
12309
12310 // Debug build checks
12311 #if Q3_DEBUG
12312 if (0) // Further checks on triMeshData
12313 return(kQ3Failure);
12314
12315 if (0) // Further checks on view
12316 return(kQ3Failure);
12317 #endif
12318
12319
12320
12321 // Call the bottleneck
12322 E3System_Bottleneck();
12323
12324
12325
12326 // Call our implementation
12327 return(E3TriMesh_Submit(triMeshData, view));
12328 }
12329
12330
12331
12332
12333
12334 //=============================================================================
12335 // Q3TriMesh_SetData : Quesa API entry point.
12336 //-----------------------------------------------------------------------------
12337 TQ3Status
Q3TriMesh_SetData(TQ3GeometryObject triMesh,const TQ3TriMeshData * triMeshData)12338 Q3TriMesh_SetData(TQ3GeometryObject triMesh, const TQ3TriMeshData *triMeshData)
12339 {
12340
12341
12342 // Release build checks
12343 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triMesh ), kQ3Failure);
12344 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triMeshData), kQ3Failure);
12345
12346
12347
12348 // Debug build checks
12349 #if Q3_DEBUG
12350 if (0) // Further checks on triMesh
12351 return(kQ3Failure);
12352
12353 if (0) // Further checks on triMeshData
12354 return(kQ3Failure);
12355 #endif
12356
12357
12358
12359 // Call the bottleneck
12360 E3System_Bottleneck();
12361
12362
12363
12364 // Call our implementation
12365 return(E3TriMesh_SetData(triMesh, triMeshData));
12366 }
12367
12368
12369
12370
12371
12372 //=============================================================================
12373 // Q3TriMesh_GetData : Quesa API entry point.
12374 //-----------------------------------------------------------------------------
12375 TQ3Status
Q3TriMesh_GetData(TQ3GeometryObject triMesh,TQ3TriMeshData * triMeshData)12376 Q3TriMesh_GetData(TQ3GeometryObject triMesh, TQ3TriMeshData *triMeshData)
12377 {
12378
12379
12380 // Release build checks
12381 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triMesh ), kQ3Failure);
12382 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triMeshData), kQ3Failure);
12383
12384
12385
12386 // Debug build checks
12387 #if Q3_DEBUG
12388 if (0) // Further checks on triMesh
12389 return(kQ3Failure);
12390
12391 if (0) // Further checks on triMeshData
12392 return(kQ3Failure);
12393 #endif
12394
12395
12396
12397 // Call the bottleneck
12398 E3System_Bottleneck();
12399
12400
12401
12402 // Call our implementation
12403 return(E3TriMesh_GetData(triMesh, triMeshData));
12404 }
12405
12406
12407
12408
12409
12410 //=============================================================================
12411 // Q3TriMesh_EmptyData : Quesa API entry point.
12412 //-----------------------------------------------------------------------------
12413 TQ3Status
Q3TriMesh_EmptyData(TQ3TriMeshData * triMeshData)12414 Q3TriMesh_EmptyData(TQ3TriMeshData *triMeshData)
12415 {
12416
12417
12418 // Release build checks
12419 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triMeshData), kQ3Failure);
12420
12421
12422
12423 // Debug build checks
12424 #if Q3_DEBUG
12425 if (0) // Further checks on triMeshData
12426 return(kQ3Failure);
12427 #endif
12428
12429
12430
12431 // Call the bottleneck
12432 E3System_Bottleneck();
12433
12434
12435
12436 // Call our implementation
12437 return(E3TriMesh_EmptyData(triMeshData));
12438 }
12439
12440
12441
12442
12443
12444 //=============================================================================
12445 // Q3TriMesh_LockData : Quesa API entry point.
12446 //-----------------------------------------------------------------------------
12447 TQ3Status
Q3TriMesh_LockData(TQ3GeometryObject triMesh,TQ3Boolean readOnly,TQ3TriMeshData ** triMeshData)12448 Q3TriMesh_LockData(TQ3GeometryObject triMesh, TQ3Boolean readOnly, TQ3TriMeshData **triMeshData)
12449 {
12450
12451
12452 // Release build checks
12453 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triMesh ), kQ3Failure);
12454 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(triMeshData), kQ3Failure);
12455
12456
12457
12458 // Debug build checks
12459 #if Q3_DEBUG
12460 if (0) // Further checks on triMesh
12461 return(kQ3Failure);
12462
12463 if (0) // Further checks on readOnly
12464 return(kQ3Failure);
12465
12466 if (0) // Further checks on triMeshData
12467 return(kQ3Failure);
12468 #endif
12469
12470
12471
12472 // Call the bottleneck
12473 E3System_Bottleneck();
12474
12475
12476
12477 // Call our implementation
12478 return(E3TriMesh_LockData(triMesh, readOnly, triMeshData));
12479 }
12480
12481
12482
12483
12484
12485 //=============================================================================
12486 // Q3TriMesh_UnlockData : Quesa API entry point.
12487 //-----------------------------------------------------------------------------
12488 TQ3Status
Q3TriMesh_UnlockData(TQ3GeometryObject triMesh)12489 Q3TriMesh_UnlockData(TQ3GeometryObject triMesh)
12490 {
12491
12492
12493 // Release build checks
12494 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( triMesh ), kQ3Failure);
12495
12496
12497
12498 // Debug build checks
12499 #if Q3_DEBUG
12500 if (0) // Further checks on triMesh
12501 return(kQ3Failure);
12502 #endif
12503
12504
12505
12506 // Call the bottleneck
12507 E3System_Bottleneck();
12508
12509
12510
12511 // Call our implementation
12512 return(E3TriMesh_UnlockData(triMesh));
12513 }
12514
12515
12516
12517
12518
12519 //=============================================================================
12520 // Q3TriMesh_OptimizeData : Quesa API entry point.
12521 //-----------------------------------------------------------------------------
Q3TriMesh_OptimizeData(const TQ3TriMeshData * inData,TQ3TriMeshData * outData,TQ3Boolean * outDidChange)12522 TQ3Status Q3TriMesh_OptimizeData( const TQ3TriMeshData* inData,
12523 TQ3TriMeshData* outData,
12524 TQ3Boolean* outDidChange )
12525 {
12526 // Release build checks
12527 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(inData), kQ3Failure);
12528 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(outData), kQ3Failure);
12529 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(outDidChange), kQ3Failure);
12530
12531
12532
12533 // Call the bottleneck
12534 E3System_Bottleneck();
12535
12536
12537
12538 // Call our implementation
12539 TQ3Status theStatus = E3TriMesh_OptimizeData( *inData, *outData, *outDidChange );
12540
12541 return theStatus;
12542 }
12543
12544
12545
12546
12547
12548 //=============================================================================
12549 // Q3TriMesh_Optimize : Quesa API entry point.
12550 //-----------------------------------------------------------------------------
Q3TriMesh_Optimize(TQ3GeometryObject inTriMesh)12551 TQ3GeometryObject Q3TriMesh_Optimize( TQ3GeometryObject inTriMesh )
12552 {
12553 Q3_REQUIRE_OR_RESULT( E3Geometry_IsOfMyClass ( inTriMesh ), NULL);
12554
12555
12556
12557 // Call the bottleneck
12558 E3System_Bottleneck();
12559
12560
12561
12562 // Call our implementation
12563 TQ3GeometryObject theGeom = E3TriMesh_Optimize( inTriMesh );
12564
12565 return theGeom;
12566
12567 }
12568