1 /* NAME:
2 QD3DIO.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 "E3IO.h"
49 #include "E3IOData.h"
50 #include "E3IOFileFormat.h"
51 #include "E3FFW_3DMFBin_Writer.h"
52 #include "E3View.h"
53
54
55
56
57
58 //=============================================================================
59 // Internal constants
60 //-----------------------------------------------------------------------------
61 // Internal constants go here
62
63
64
65
66
67 //=============================================================================
68 // Internal types
69 //-----------------------------------------------------------------------------
70 // Internal types go here
71
72
73
74
75
76 //=============================================================================
77 // Internal macros
78 //-----------------------------------------------------------------------------
79 // Internal macros go here
80
81
82
83
84
85 //=============================================================================
86 // Public functions
87 //-----------------------------------------------------------------------------
88 // Q3XView_SubmitWriteData : Quesa API entry point.
89 //-----------------------------------------------------------------------------
90 #pragma mark -
91 TQ3Status
Q3XView_SubmitWriteData(TQ3ViewObject view,TQ3Size size,void * data,TQ3XDataDeleteMethod deleteData)92 Q3XView_SubmitWriteData(TQ3ViewObject view, TQ3Size size, void *data, TQ3XDataDeleteMethod deleteData)
93 {
94
95
96 // Release build checks
97 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
98
99
100
101 // Call the bottleneck
102 E3System_Bottleneck();
103
104
105
106 // Call our implementation
107 return(E3XView_SubmitWriteData(view, size, data, deleteData));
108 }
109
110
111
112
113
114 //=============================================================================
115 // Q3XView_SubmitSubObjectData : Quesa API entry point.
116 //-----------------------------------------------------------------------------
117 TQ3Status
Q3XView_SubmitSubObjectData(TQ3ViewObject view,TQ3XObjectClass objectClass,TQ3Uns32 size,void * data,TQ3XDataDeleteMethod deleteData)118 Q3XView_SubmitSubObjectData(TQ3ViewObject view, TQ3XObjectClass objectClass, TQ3Uns32 size, void *data, TQ3XDataDeleteMethod deleteData)
119 {
120
121
122 // Release build checks
123 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
124 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
125
126
127
128 // Debug build checks
129 #if Q3_DEBUG
130 if (0) // Further checks on view
131 return(kQ3Failure);
132
133 if (0) // Further checks on objectClass
134 return(kQ3Failure);
135
136 if (0) // Further checks on size
137 return(kQ3Failure);
138
139 if (0) // Further checks on data
140 return(kQ3Failure);
141
142 if (0) // Further checks on deleteData
143 return(kQ3Failure);
144 #endif
145
146
147
148 // Call the bottleneck
149 E3System_Bottleneck();
150
151
152
153 // Call our implementation
154 return(E3XView_SubmitSubObjectData(view, objectClass, size, data, deleteData));
155 }
156
157
158
159
160
161 //=============================================================================
162 // Q3File_New : Quesa API entry point.
163 //-----------------------------------------------------------------------------
164 TQ3FileObject
Q3File_New(void)165 Q3File_New(void)
166 {
167
168
169 // Call the bottleneck
170 E3System_Bottleneck();
171
172
173
174 // Call our implementation
175 return(E3File_New());
176 }
177
178
179
180
181
182 //=============================================================================
183 // Q3File_GetStorage : Quesa API entry point.
184 //-----------------------------------------------------------------------------
185 TQ3Status
Q3File_GetStorage(TQ3FileObject theFile,TQ3StorageObject * storage)186 Q3File_GetStorage(TQ3FileObject theFile, TQ3StorageObject *storage)
187 {
188
189
190 // Release build checks
191 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
192 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(storage), kQ3Failure);
193
194
195
196 // Debug build checks
197 #if Q3_DEBUG
198 if (0) // Further checks on theFile
199 return(kQ3Failure);
200
201 if (0) // Further checks on storage
202 return(kQ3Failure);
203 #endif
204
205
206
207 // Call the bottleneck
208 E3System_Bottleneck();
209
210
211
212 // Call our implementation
213 return ( (E3File*) theFile )->GetStorage ( storage ) ;
214 }
215
216
217
218
219
220 //=============================================================================
221 // Q3File_SetStorage : Quesa API entry point.
222 //-----------------------------------------------------------------------------
223 TQ3Status
Q3File_SetStorage(TQ3FileObject theFile,TQ3StorageObject storage)224 Q3File_SetStorage(TQ3FileObject theFile, TQ3StorageObject storage)
225 {
226
227
228 // Release build checks
229 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
230 // storage can be NULL
231
232
233 // Debug build checks
234 #if Q3_DEBUG
235 if (0) // Further checks on theFile
236 return(kQ3Failure);
237
238 if (0) // Further checks on storage
239 return(kQ3Failure);
240 #endif
241
242
243
244 // Call the bottleneck
245 E3System_Bottleneck();
246
247
248
249 // Call our implementation
250 return ( (E3File*) theFile )->SetStorage ( storage ) ;
251 }
252
253
254
255
256
257 //=============================================================================
258 // Q3File_OpenRead : Quesa API entry point.
259 //-----------------------------------------------------------------------------
260 TQ3Status
Q3File_OpenRead(TQ3FileObject theFile,TQ3FileMode * mode)261 Q3File_OpenRead(TQ3FileObject theFile, TQ3FileMode *mode)
262 {
263
264
265 // Release build checks
266 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
267
268
269
270 // Debug build checks
271 #if Q3_DEBUG
272 if (0) // Further checks on theFile
273 return(kQ3Failure);
274
275 if (0) // Further checks on mode
276 return(kQ3Failure);
277 #endif
278
279
280
281 // Call the bottleneck
282 E3System_Bottleneck();
283
284
285
286 // Call our implementation
287 return ( (E3File*) theFile )->OpenRead ( mode ) ;
288 }
289
290
291
292
293
294 //=============================================================================
295 // Q3File_OpenWrite : Quesa API entry point.
296 //-----------------------------------------------------------------------------
297 TQ3Status
Q3File_OpenWrite(TQ3FileObject theFile,TQ3FileMode mode)298 Q3File_OpenWrite(TQ3FileObject theFile, TQ3FileMode mode)
299 {
300
301
302 // Release build checks
303 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
304
305
306
307 // Debug build checks
308 #if Q3_DEBUG
309 if (0) // Further checks on theFile
310 return(kQ3Failure);
311
312 if (0) // Further checks on mode
313 return(kQ3Failure);
314 #endif
315
316
317
318 // Call the bottleneck
319 E3System_Bottleneck();
320
321
322
323 // Call our implementation
324 return ( (E3File*) theFile )->OpenWrite ( mode ) ;
325 }
326
327
328
329
330
331 //=============================================================================
332 // Q3File_IsOpen : Quesa API entry point.
333 //-----------------------------------------------------------------------------
334 TQ3Status
Q3File_IsOpen(TQ3FileObject theFile,TQ3Boolean * isOpen)335 Q3File_IsOpen(TQ3FileObject theFile, TQ3Boolean *isOpen)
336 {
337
338
339 // Release build checks
340 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
341 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(isOpen), kQ3Failure);
342
343
344
345 // Debug build checks
346 #if Q3_DEBUG
347 if (0) // Further checks on theFile
348 return(kQ3Failure);
349
350 if (0) // Further checks on isOpen
351 return(kQ3Failure);
352 #endif
353
354
355
356 // Call the bottleneck
357 E3System_Bottleneck();
358
359
360
361 // Call our implementation
362 return ( (E3File*) theFile )->IsOpen ( isOpen ) ;
363 }
364
365
366
367
368
369 //=============================================================================
370 // Q3File_GetMode : Quesa API entry point.
371 //-----------------------------------------------------------------------------
372 TQ3Status
Q3File_GetMode(TQ3FileObject theFile,TQ3FileMode * mode)373 Q3File_GetMode(TQ3FileObject theFile, TQ3FileMode *mode)
374 {
375
376
377 // Release build checks
378 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
379 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(mode), kQ3Failure);
380
381
382
383 // Debug build checks
384 #if Q3_DEBUG
385 if (0) // Further checks on theFile
386 return(kQ3Failure);
387
388 if (0) // Further checks on mode
389 return(kQ3Failure);
390 #endif
391
392
393
394 // Call the bottleneck
395 E3System_Bottleneck();
396
397
398
399 // Call our implementation
400 return ( (E3File*) theFile )->GetMode ( mode ) ;
401 }
402
403
404
405
406
407 //=============================================================================
408 // Q3File_GetVersion : Quesa API entry point.
409 //-----------------------------------------------------------------------------
410 TQ3Status
Q3File_GetVersion(TQ3FileObject theFile,TQ3FileVersion * version)411 Q3File_GetVersion(TQ3FileObject theFile, TQ3FileVersion *version)
412 {
413
414
415 // Release build checks
416 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
417 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(version), kQ3Failure);
418
419
420
421 // Debug build checks
422 #if Q3_DEBUG
423 if (0) // Further checks on theFile
424 return(kQ3Failure);
425
426 if (0) // Further checks on version
427 return(kQ3Failure);
428 #endif
429
430
431
432 // Call the bottleneck
433 E3System_Bottleneck();
434
435
436
437 // Call our implementation
438 return ( (E3File*) theFile )->GetVersion ( version ) ;
439 }
440
441
442
443
444
445 //=============================================================================
446 // Q3File_Close : Quesa API entry point.
447 //-----------------------------------------------------------------------------
448 TQ3Status
Q3File_Close(TQ3FileObject theFile)449 Q3File_Close(TQ3FileObject theFile)
450 {
451
452
453 // Release build checks
454 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
455
456
457
458 // Debug build checks
459 #if Q3_DEBUG
460 if (0) // Further checks on theFile
461 return(kQ3Failure);
462 #endif
463
464
465
466 // Call the bottleneck
467 E3System_Bottleneck();
468
469
470
471 // Call our implementation
472 return ( (E3File*) theFile)->Close () ;
473 }
474
475
476
477
478
479 //=============================================================================
480 // Q3File_Cancel : Quesa API entry point.
481 //-----------------------------------------------------------------------------
482 TQ3Status
Q3File_Cancel(TQ3FileObject theFile)483 Q3File_Cancel(TQ3FileObject theFile)
484 {
485
486
487 // Release build checks
488 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
489
490
491
492 // Debug build checks
493 #if Q3_DEBUG
494 if (0) // Further checks on theFile
495 return(kQ3Failure);
496 #endif
497
498
499
500 // Call the bottleneck
501 E3System_Bottleneck();
502
503
504
505 // Call our implementation
506 return ( (E3File*) theFile )->Cancel () ;
507 }
508
509
510
511
512
513 //=============================================================================
514 // Q3View_StartWriting : Quesa API entry point.
515 //-----------------------------------------------------------------------------
516 TQ3Status
Q3View_StartWriting(TQ3ViewObject view,TQ3FileObject theFile)517 Q3View_StartWriting(TQ3ViewObject view, TQ3FileObject theFile)
518 {
519
520
521 // Release build checks
522 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3Failure);
523 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
524
525
526
527 // Debug build checks
528 #if Q3_DEBUG
529 if (0) // Further checks on view
530 return(kQ3Failure);
531
532 if (0) // Further checks on theFile
533 return(kQ3Failure);
534 #endif
535
536
537
538 // Call the bottleneck
539 E3System_Bottleneck();
540
541
542
543 // Call our implementation
544 return(E3View_StartWriting(view, theFile));
545 }
546
547
548
549
550
551 //=============================================================================
552 // Q3View_EndWriting : Quesa API entry point.
553 //-----------------------------------------------------------------------------
554 TQ3ViewStatus
Q3View_EndWriting(TQ3ViewObject view)555 Q3View_EndWriting(TQ3ViewObject view)
556 {
557
558
559 // Release build checks
560 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), kQ3ViewStatusError);
561
562
563
564 // Debug build checks
565 #if Q3_DEBUG
566 if (0) // Further checks on view
567 return(kQ3ViewStatusError);
568 #endif
569
570
571
572 // Call the bottleneck
573 E3System_Bottleneck();
574
575
576
577 // Call our implementation
578 return(E3View_EndWriting(view));
579 }
580
581
582
583 #pragma mark -
584
585 //=============================================================================
586 // Q3File_GetNextObjectType : Quesa API entry point.
587 //-----------------------------------------------------------------------------
588 TQ3ObjectType
Q3File_GetNextObjectType(TQ3FileObject theFile)589 Q3File_GetNextObjectType(TQ3FileObject theFile)
590 {
591
592
593 // Release build checks
594 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), kQ3ObjectTypeInvalid);
595
596
597
598 // Debug build checks
599 #if Q3_DEBUG
600 if (0) // Further checks on theFile
601 return(kQ3ObjectTypeInvalid);
602 #endif
603
604
605
606 // Call the bottleneck
607 E3System_Bottleneck();
608
609
610
611 // Call our implementation
612 return ( (E3File*) theFile )->GetNextObjectType () ;
613 }
614
615
616
617
618
619 //=============================================================================
620 // Q3File_IsNextObjectOfType : Quesa API entry point.
621 //-----------------------------------------------------------------------------
622 TQ3Boolean
Q3File_IsNextObjectOfType(TQ3FileObject theFile,TQ3ObjectType ofType)623 Q3File_IsNextObjectOfType(TQ3FileObject theFile, TQ3ObjectType ofType)
624 {
625
626
627 // Release build checks
628 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), kQ3False);
629
630
631
632 // Debug build checks
633 #if Q3_DEBUG
634 if (0) // Further checks on theFile
635 return(kQ3False);
636
637 if (0) // Further checks on ofType
638 return(kQ3False);
639 #endif
640
641
642
643 // Call the bottleneck
644 E3System_Bottleneck();
645
646
647
648 // Call our implementation
649 return ( (E3File*) theFile )->IsNextObjectOfType ( ofType ) ;
650 }
651
652
653
654
655
656 //=============================================================================
657 // Q3File_ReadObject : Quesa API entry point.
658 //-----------------------------------------------------------------------------
659 TQ3Object
Q3File_ReadObject(TQ3FileObject theFile)660 Q3File_ReadObject(TQ3FileObject theFile)
661 {
662
663
664 // Release build checks
665 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), NULL);
666
667
668
669 // Debug build checks
670 #if Q3_DEBUG
671 if (0) // Further checks on theFile
672 return(NULL);
673 #endif
674
675
676
677 // Call the bottleneck
678 E3System_Bottleneck();
679
680
681
682 // Call our implementation
683 return ( (E3File*) theFile )->ReadObject () ;
684 }
685
686
687
688
689
690 //=============================================================================
691 // Q3File_SkipObject : Quesa API entry point.
692 //-----------------------------------------------------------------------------
693 TQ3Status
Q3File_SkipObject(TQ3FileObject theFile)694 Q3File_SkipObject(TQ3FileObject theFile)
695 {
696
697
698 // Release build checks
699 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
700
701
702
703 // Debug build checks
704 #if Q3_DEBUG
705 if (0) // Further checks on theFile
706 return(kQ3Failure);
707 #endif
708
709
710
711 // Call the bottleneck
712 E3System_Bottleneck();
713
714
715
716 // Call our implementation
717 return ( (E3File*) theFile )->SkipObject () ;
718 }
719
720
721
722
723
724 //=============================================================================
725 // Q3File_IsEndOfData : Quesa API entry point.
726 //-----------------------------------------------------------------------------
727 TQ3Boolean
Q3File_IsEndOfData(TQ3FileObject theFile)728 Q3File_IsEndOfData(TQ3FileObject theFile)
729 {
730
731
732 // Release build checks
733 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), kQ3False);
734
735
736
737 // Debug build checks
738 #if Q3_DEBUG
739 if (0) // Further checks on theFile
740 return(kQ3False);
741 #endif
742
743
744
745 // Call the bottleneck
746 E3System_Bottleneck();
747
748
749
750 // Call our implementation
751 return ( (E3File*) theFile )->IsEndOfData () ;
752 }
753
754
755
756
757
758 //=============================================================================
759 // Q3File_IsEndOfContainer : Quesa API entry point.
760 //-----------------------------------------------------------------------------
761 TQ3Boolean
Q3File_IsEndOfContainer(TQ3FileObject theFile,TQ3Object rootObject)762 Q3File_IsEndOfContainer(TQ3FileObject theFile, TQ3Object rootObject)
763 {
764
765
766 // Release build checks
767 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), kQ3False);
768 // rootObject can be NULL
769
770
771 // Debug build checks
772 #if Q3_DEBUG
773 if (0) // Further checks on theFile
774 return(kQ3False);
775
776 if (0) // Further checks on rootObject
777 return(kQ3False);
778 #endif
779
780
781
782 // Call the bottleneck
783 E3System_Bottleneck();
784
785
786
787 // Call our implementation
788 return ( (E3File*) theFile )->IsEndOfContainer ( rootObject ) ;
789 }
790
791
792
793
794
795 //=============================================================================
796 // Q3File_IsEndOfFile : Quesa API entry point.
797 //-----------------------------------------------------------------------------
798 TQ3Boolean
Q3File_IsEndOfFile(TQ3FileObject theFile)799 Q3File_IsEndOfFile(TQ3FileObject theFile)
800 {
801
802
803 // Release build checks
804 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), kQ3False);
805
806
807
808 // Debug build checks
809 #if Q3_DEBUG
810 if (0) // Further checks on theFile
811 return(kQ3False);
812 #endif
813
814
815
816 // Call the bottleneck
817 E3System_Bottleneck();
818
819
820
821 // Call our implementation
822 return ( (E3File*) theFile )->IsEndOfFile () ;
823 }
824
825
826
827
828
829 //=============================================================================
830 // Q3File_MarkAsExternalReference : Quesa API entry point.
831 //-----------------------------------------------------------------------------
832 TQ3Status
Q3File_MarkAsExternalReference(TQ3FileObject theFile,TQ3SharedObject sharedObject)833 Q3File_MarkAsExternalReference(TQ3FileObject theFile, TQ3SharedObject sharedObject)
834 {
835
836
837 // Release build checks
838 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
839 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(sharedObject, (kQ3ObjectTypeShared)), kQ3Failure);
840
841
842
843 // Debug build checks
844 #if Q3_DEBUG
845 if (0) // Further checks on theFile
846 return(kQ3Failure);
847
848 if (0) // Further checks on sharedObject
849 return(kQ3Failure);
850 #endif
851
852
853
854 // Call the bottleneck
855 E3System_Bottleneck();
856
857
858
859 // Call our implementation
860 return(E3File_MarkAsExternalReference(theFile, sharedObject));
861 }
862
863
864
865
866
867 //=============================================================================
868 // Q3File_GetExternalReferences : Quesa API entry point.
869 //-----------------------------------------------------------------------------
870 TQ3GroupObject
Q3File_GetExternalReferences(TQ3FileObject theFile)871 Q3File_GetExternalReferences(TQ3FileObject theFile)
872 {
873
874
875 // Release build checks
876 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), NULL);
877
878
879
880 // Debug build checks
881 #if Q3_DEBUG
882 if (0) // Further checks on theFile
883 return(NULL);
884 #endif
885
886
887
888 // Call the bottleneck
889 E3System_Bottleneck();
890
891
892
893 // Call our implementation
894 return(E3File_GetExternalReferences(theFile));
895 }
896
897
898 #pragma mark -
899
900
901 //=============================================================================
902 // Q3Shared_ClearEditTracking : Quesa API entry point.
903 //-----------------------------------------------------------------------------
904 TQ3Status
Q3Shared_ClearEditTracking(TQ3SharedObject sharedObject)905 Q3Shared_ClearEditTracking(TQ3SharedObject sharedObject)
906 {
907
908
909 // Release build checks
910 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(sharedObject, (kQ3ObjectTypeShared)), kQ3Failure);
911
912
913
914 // Debug build checks
915 #if Q3_DEBUG
916 if (0) // Further checks on sharedObject
917 return(kQ3Failure);
918 #endif
919
920
921
922 // Call the bottleneck
923 E3System_Bottleneck();
924
925
926
927 // Call our implementation
928 return(E3Shared_ClearEditTracking(sharedObject));
929 }
930
931
932
933
934
935 //=============================================================================
936 // Q3Shared_GetEditTrackingState : Quesa API entry point.
937 //-----------------------------------------------------------------------------
938 TQ3Boolean
Q3Shared_GetEditTrackingState(TQ3SharedObject sharedObject)939 Q3Shared_GetEditTrackingState(TQ3SharedObject sharedObject)
940 {
941
942
943 // Release build checks
944 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(sharedObject, kQ3ObjectTypeShared), kQ3False);
945
946
947
948 // Debug build checks
949 #if Q3_DEBUG
950 if (0) // Further checks on sharedObject
951 return(kQ3False);
952 #endif
953
954
955
956 // Call the bottleneck
957 E3System_Bottleneck();
958
959
960
961 // Call our implementation
962 return(E3Shared_GetEditTrackingState(sharedObject));
963 }
964
965
966
967
968
969 //=============================================================================
970 // Q3File_SetReadInGroup : Quesa API entry point.
971 //-----------------------------------------------------------------------------
972 TQ3Status
Q3File_SetReadInGroup(TQ3FileObject theFile,TQ3FileReadGroupState readGroupState)973 Q3File_SetReadInGroup(TQ3FileObject theFile, TQ3FileReadGroupState readGroupState)
974 {
975
976
977 // Release build checks
978 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
979
980
981
982 // Debug build checks
983 #if Q3_DEBUG
984 if (0) // Further checks on theFile
985 return(kQ3Failure);
986
987 if (0) // Further checks on readGroupState
988 return(kQ3Failure);
989 #endif
990
991
992
993 // Call the bottleneck
994 E3System_Bottleneck();
995
996
997
998 // Call our implementation
999 return ( (E3File*) theFile )->SetReadInGroup ( readGroupState ) ;
1000 }
1001
1002
1003
1004
1005
1006 //=============================================================================
1007 // Q3File_GetReadInGroup : Quesa API entry point.
1008 //-----------------------------------------------------------------------------
1009 TQ3Status
Q3File_GetReadInGroup(TQ3FileObject theFile,TQ3FileReadGroupState * readGroupState)1010 Q3File_GetReadInGroup(TQ3FileObject theFile, TQ3FileReadGroupState *readGroupState)
1011 {
1012
1013
1014 // Release build checks
1015 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1016 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(readGroupState), kQ3Failure);
1017
1018
1019
1020 // Debug build checks
1021 #if Q3_DEBUG
1022 if (0) // Further checks on theFile
1023 return(kQ3Failure);
1024
1025 if (0) // Further checks on readGroupState
1026 return(kQ3Failure);
1027 #endif
1028
1029
1030
1031 // Call the bottleneck
1032 E3System_Bottleneck();
1033
1034
1035
1036 // Call our implementation
1037 return ( (E3File*) theFile )->GetReadInGroup ( readGroupState ) ;
1038 }
1039
1040
1041
1042
1043
1044 //=============================================================================
1045 // Q3File_SetIdleMethod : Quesa API entry point.
1046 //-----------------------------------------------------------------------------
1047 TQ3Status
Q3File_SetIdleMethod(TQ3FileObject theFile,TQ3FileIdleMethod idle,const void * idleData)1048 Q3File_SetIdleMethod(TQ3FileObject theFile, TQ3FileIdleMethod idle, const void *idleData)
1049 {
1050
1051
1052 // Release build checks
1053 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1054
1055
1056
1057 // Debug build checks
1058 #if Q3_DEBUG
1059 if (0) // Further checks on theFile
1060 return(kQ3Failure);
1061
1062 if (0) // Further checks on idle
1063 return(kQ3Failure);
1064
1065 if (0) // Further checks on idleData
1066 return(kQ3Failure);
1067 #endif
1068
1069
1070
1071 // Call the bottleneck
1072 E3System_Bottleneck();
1073
1074
1075
1076 // Call our implementation
1077 return ( (E3File*) theFile )->SetIdleMethod ( idle, idleData ) ;
1078 }
1079
1080
1081
1082 #pragma mark -
1083
1084 //=============================================================================
1085 // Q3NewLine_Write : Quesa API entry point.
1086 //-----------------------------------------------------------------------------
1087 TQ3Status
Q3NewLine_Write(TQ3FileObject theFile)1088 Q3NewLine_Write(TQ3FileObject theFile)
1089 {
1090
1091
1092 // Release build checks
1093 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1094
1095
1096
1097 // Debug build checks
1098 #if Q3_DEBUG
1099 if (0) // Further checks on theFile
1100 return(kQ3Failure);
1101 #endif
1102
1103
1104
1105 // Call the bottleneck
1106 E3System_Bottleneck();
1107
1108
1109
1110 // Call our implementation
1111 return(E3NewLine_Write( (E3File*) theFile ));
1112 }
1113
1114
1115
1116
1117
1118 //=============================================================================
1119 // Q3Uns8_Read : Quesa API entry point.
1120 //-----------------------------------------------------------------------------
1121 TQ3Status
Q3Uns8_Read(TQ3Uns8 * data,TQ3FileObject theFile)1122 Q3Uns8_Read(TQ3Uns8 *data, TQ3FileObject theFile)
1123 {
1124
1125
1126 // Release build checks
1127 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1128 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1129
1130
1131
1132 // Debug build checks
1133 #if Q3_DEBUG
1134 if (0) // Further checks on data
1135 return(kQ3Failure);
1136
1137 if (0) // Further checks on theFile
1138 return(kQ3Failure);
1139 #endif
1140
1141
1142
1143 // Call the bottleneck
1144 E3System_Bottleneck();
1145
1146
1147
1148 // Call our implementation
1149 return(E3Uns8_Read(data, (E3File*) theFile ));
1150 }
1151
1152
1153
1154
1155
1156 //=============================================================================
1157 // Q3Uns8_ReadArray : Quesa API entry point.
1158 //-----------------------------------------------------------------------------
1159 TQ3Status
Q3Uns8_ReadArray(TQ3Uns32 numNums,TQ3Uns8 * intArray,TQ3FileObject theFile)1160 Q3Uns8_ReadArray (
1161 TQ3Uns32 numNums,
1162 TQ3Uns8* intArray,
1163 TQ3FileObject theFile
1164 )
1165 {
1166 // Release build checks
1167 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(intArray), kQ3Failure);
1168 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1169
1170
1171
1172 // Call the bottleneck
1173 E3System_Bottleneck();
1174
1175
1176
1177 // Call our implementation
1178 return (E3Uns8_ReadArray( numNums, intArray, (E3File*) theFile ));
1179 }
1180
1181
1182
1183
1184
1185 //=============================================================================
1186 // Q3Uns8_Write : Quesa API entry point.
1187 //-----------------------------------------------------------------------------
1188 TQ3Status
Q3Uns8_Write(TQ3Uns8 data,TQ3FileObject theFile)1189 Q3Uns8_Write(TQ3Uns8 data, TQ3FileObject theFile)
1190 {
1191
1192
1193 // Release build checks
1194 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1195
1196
1197
1198 // Debug build checks
1199 #if Q3_DEBUG
1200 if (0) // Further checks on data
1201 return(kQ3Failure);
1202
1203 if (0) // Further checks on theFile
1204 return(kQ3Failure);
1205 #endif
1206
1207
1208
1209 // Call the bottleneck
1210 E3System_Bottleneck();
1211
1212
1213
1214 // Call our implementation
1215 return(E3Uns8_Write(data, (E3File*) theFile ));
1216 }
1217
1218
1219
1220
1221
1222 //=============================================================================
1223 // Q3Uns16_Read : Quesa API entry point.
1224 //-----------------------------------------------------------------------------
1225 TQ3Status
Q3Uns16_Read(TQ3Uns16 * data,TQ3FileObject theFile)1226 Q3Uns16_Read(TQ3Uns16 *data, TQ3FileObject theFile)
1227 {
1228
1229
1230 // Release build checks
1231 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1232 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1233
1234
1235
1236 // Debug build checks
1237 #if Q3_DEBUG
1238 if (0) // Further checks on data
1239 return(kQ3Failure);
1240
1241 if (0) // Further checks on theFile
1242 return(kQ3Failure);
1243 #endif
1244
1245
1246
1247 // Call the bottleneck
1248 E3System_Bottleneck();
1249
1250
1251
1252 // Call our implementation
1253 return(E3Uns16_Read(data, (E3File*) theFile ));
1254 }
1255
1256
1257
1258
1259
1260 //=============================================================================
1261 // Q3Uns16_ReadArray : Quesa API entry point.
1262 //-----------------------------------------------------------------------------
1263 TQ3Status
Q3Uns16_ReadArray(TQ3Uns32 numNums,TQ3Uns16 * intArray,TQ3FileObject theFile)1264 Q3Uns16_ReadArray (
1265 TQ3Uns32 numNums,
1266 TQ3Uns16* intArray,
1267 TQ3FileObject theFile
1268 )
1269 {
1270 // Release build checks
1271 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(intArray), kQ3Failure);
1272 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1273
1274
1275
1276 // Call the bottleneck
1277 E3System_Bottleneck();
1278
1279
1280
1281 // Call our implementation
1282 return (E3Uns16_ReadArray( numNums, intArray, (E3File*) theFile ));
1283 }
1284
1285
1286
1287
1288
1289 //=============================================================================
1290 // Q3Uns16_Write : Quesa API entry point.
1291 //-----------------------------------------------------------------------------
1292 TQ3Status
Q3Uns16_Write(TQ3Uns16 data,TQ3FileObject theFile)1293 Q3Uns16_Write(TQ3Uns16 data, TQ3FileObject theFile)
1294 {
1295
1296
1297 // Release build checks
1298 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1299
1300
1301
1302 // Debug build checks
1303 #if Q3_DEBUG
1304 if (0) // Further checks on data
1305 return(kQ3Failure);
1306
1307 if (0) // Further checks on theFile
1308 return(kQ3Failure);
1309 #endif
1310
1311
1312
1313 // Call the bottleneck
1314 E3System_Bottleneck();
1315
1316
1317
1318 // Call our implementation
1319 return(E3Uns16_Write(data, (E3File*) theFile ));
1320 }
1321
1322
1323
1324
1325
1326 //=============================================================================
1327 // Q3Uns32_Read : Quesa API entry point.
1328 //-----------------------------------------------------------------------------
1329 TQ3Status
Q3Uns32_Read(TQ3Uns32 * data,TQ3FileObject theFile)1330 Q3Uns32_Read(TQ3Uns32 *data, TQ3FileObject theFile)
1331 {
1332
1333
1334 // Release build checks
1335 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1336 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1337
1338
1339
1340 // Debug build checks
1341 #if Q3_DEBUG
1342 if (0) // Further checks on data
1343 return(kQ3Failure);
1344
1345 if (0) // Further checks on theFile
1346 return(kQ3Failure);
1347 #endif
1348
1349
1350
1351 // Call the bottleneck
1352 E3System_Bottleneck();
1353
1354
1355
1356 // Call our implementation
1357 return(E3Uns32_Read(data, (E3File*) theFile ));
1358 }
1359
1360
1361
1362
1363
1364 //=============================================================================
1365 // Q3Uns32_ReadArray : Quesa API entry point.
1366 //-----------------------------------------------------------------------------
1367 TQ3Status
Q3Uns32_ReadArray(TQ3Uns32 numNums,TQ3Uns32 * intArray,TQ3FileObject theFile)1368 Q3Uns32_ReadArray (
1369 TQ3Uns32 numNums,
1370 TQ3Uns32* intArray,
1371 TQ3FileObject theFile
1372 )
1373 {
1374 // Release build checks
1375 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(intArray), kQ3Failure);
1376 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1377
1378
1379
1380 // Call the bottleneck
1381 E3System_Bottleneck();
1382
1383
1384
1385 // Call our implementation
1386 return (E3Uns32_ReadArray( numNums, intArray, (E3File*) theFile ));
1387 }
1388
1389
1390
1391
1392
1393 //=============================================================================
1394 // Q3Uns32_Write : Quesa API entry point.
1395 //-----------------------------------------------------------------------------
1396 TQ3Status
Q3Uns32_Write(TQ3Uns32 data,TQ3FileObject theFile)1397 Q3Uns32_Write(TQ3Uns32 data, TQ3FileObject theFile)
1398 {
1399
1400
1401 // Release build checks
1402 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1403
1404
1405
1406 // Debug build checks
1407 #if Q3_DEBUG
1408 if (0) // Further checks on data
1409 return(kQ3Failure);
1410
1411 if (0) // Further checks on theFile
1412 return(kQ3Failure);
1413 #endif
1414
1415
1416
1417 // Call the bottleneck
1418 E3System_Bottleneck();
1419
1420
1421
1422 // Call our implementation
1423 return(E3Uns32_Write(data, (E3File*) theFile ));
1424 }
1425
1426
1427
1428
1429
1430 //=============================================================================
1431 // Q3Int8_Read : Quesa API entry point.
1432 //-----------------------------------------------------------------------------
1433 TQ3Status
Q3Int8_Read(TQ3Int8 * data,TQ3FileObject theFile)1434 Q3Int8_Read(TQ3Int8 *data, TQ3FileObject theFile)
1435 {
1436
1437
1438 // Release build checks
1439 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1440 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1441
1442
1443
1444 // Debug build checks
1445 #if Q3_DEBUG
1446 if (0) // Further checks on data
1447 return(kQ3Failure);
1448
1449 if (0) // Further checks on theFile
1450 return(kQ3Failure);
1451 #endif
1452
1453
1454
1455 // Call the bottleneck
1456 E3System_Bottleneck();
1457
1458
1459
1460 // Call our implementation
1461 return(E3Int8_Read(data, (E3File*) theFile ));
1462 }
1463
1464
1465
1466
1467
1468 //=============================================================================
1469 // Q3Int8_Write : Quesa API entry point.
1470 //-----------------------------------------------------------------------------
1471 TQ3Status
Q3Int8_Write(TQ3Int8 data,TQ3FileObject theFile)1472 Q3Int8_Write(TQ3Int8 data, TQ3FileObject theFile)
1473 {
1474
1475
1476 // Release build checks
1477 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1478
1479
1480
1481 // Debug build checks
1482 #if Q3_DEBUG
1483 if (0) // Further checks on data
1484 return(kQ3Failure);
1485
1486 if (0) // Further checks on theFile
1487 return(kQ3Failure);
1488 #endif
1489
1490
1491
1492 // Call the bottleneck
1493 E3System_Bottleneck();
1494
1495
1496
1497 // Call our implementation
1498 return(E3Int8_Write(data, (E3File*) theFile ));
1499 }
1500
1501
1502
1503
1504
1505 //=============================================================================
1506 // Q3Int16_Read : Quesa API entry point.
1507 //-----------------------------------------------------------------------------
1508 TQ3Status
Q3Int16_Read(TQ3Int16 * data,TQ3FileObject theFile)1509 Q3Int16_Read(TQ3Int16 *data, TQ3FileObject theFile)
1510 {
1511
1512
1513 // Release build checks
1514 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1515 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1516
1517
1518
1519 // Debug build checks
1520 #if Q3_DEBUG
1521 if (0) // Further checks on data
1522 return(kQ3Failure);
1523
1524 if (0) // Further checks on theFile
1525 return(kQ3Failure);
1526 #endif
1527
1528
1529
1530 // Call the bottleneck
1531 E3System_Bottleneck();
1532
1533
1534
1535 // Call our implementation
1536 return(E3Int16_Read(data, (E3File*) theFile ));
1537 }
1538
1539
1540
1541
1542
1543 //=============================================================================
1544 // Q3Int16_Write : Quesa API entry point.
1545 //-----------------------------------------------------------------------------
1546 TQ3Status
Q3Int16_Write(TQ3Int16 data,TQ3FileObject theFile)1547 Q3Int16_Write(TQ3Int16 data, TQ3FileObject theFile)
1548 {
1549
1550
1551 // Release build checks
1552 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1553
1554
1555
1556 // Debug build checks
1557 #if Q3_DEBUG
1558 if (0) // Further checks on data
1559 return(kQ3Failure);
1560
1561 if (0) // Further checks on theFile
1562 return(kQ3Failure);
1563 #endif
1564
1565
1566
1567 // Call the bottleneck
1568 E3System_Bottleneck();
1569
1570
1571
1572 // Call our implementation
1573 return(E3Int16_Write(data, (E3File*) theFile ));
1574 }
1575
1576
1577
1578
1579
1580 //=============================================================================
1581 // Q3Int32_Read : Quesa API entry point.
1582 //-----------------------------------------------------------------------------
1583 TQ3Status
Q3Int32_Read(TQ3Int32 * data,TQ3FileObject theFile)1584 Q3Int32_Read(TQ3Int32 *data, TQ3FileObject theFile)
1585 {
1586
1587
1588 // Release build checks
1589 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1590 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1591
1592
1593
1594 // Debug build checks
1595 #if Q3_DEBUG
1596 if (0) // Further checks on data
1597 return(kQ3Failure);
1598
1599 if (0) // Further checks on theFile
1600 return(kQ3Failure);
1601 #endif
1602
1603
1604
1605 // Call the bottleneck
1606 E3System_Bottleneck();
1607
1608
1609
1610 // Call our implementation
1611 return(E3Int32_Read(data, (E3File*) theFile ));
1612 }
1613
1614
1615
1616
1617
1618 //=============================================================================
1619 // Q3Int32_Write : Quesa API entry point.
1620 //-----------------------------------------------------------------------------
1621 TQ3Status
Q3Int32_Write(TQ3Int32 data,TQ3FileObject theFile)1622 Q3Int32_Write(TQ3Int32 data, TQ3FileObject theFile)
1623 {
1624
1625
1626 // Release build checks
1627 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1628
1629
1630
1631 // Debug build checks
1632 #if Q3_DEBUG
1633 if (0) // Further checks on data
1634 return(kQ3Failure);
1635
1636 if (0) // Further checks on theFile
1637 return(kQ3Failure);
1638 #endif
1639
1640
1641
1642 // Call the bottleneck
1643 E3System_Bottleneck();
1644
1645
1646
1647 // Call our implementation
1648 return(E3Int32_Write(data, (E3File*) theFile ));
1649 }
1650
1651
1652
1653
1654
1655 //=============================================================================
1656 // Q3Uns64_Read : Quesa API entry point.
1657 //-----------------------------------------------------------------------------
1658 TQ3Status
Q3Uns64_Read(TQ3Uns64 * data,TQ3FileObject theFile)1659 Q3Uns64_Read(TQ3Uns64 *data, TQ3FileObject theFile)
1660 {
1661
1662
1663 // Release build checks
1664 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1665 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1666
1667
1668
1669 // Debug build checks
1670 #if Q3_DEBUG
1671 if (0) // Further checks on data
1672 return(kQ3Failure);
1673
1674 if (0) // Further checks on theFile
1675 return(kQ3Failure);
1676 #endif
1677
1678
1679
1680 // Call the bottleneck
1681 E3System_Bottleneck();
1682
1683
1684
1685 // Call our implementation
1686 return(E3Uns64_Read(data, (E3File*) theFile ));
1687 }
1688
1689
1690
1691
1692
1693 //=============================================================================
1694 // Q3Uns64_Write : Quesa API entry point.
1695 //-----------------------------------------------------------------------------
1696 TQ3Status
Q3Uns64_Write(TQ3Uns64 data,TQ3FileObject theFile)1697 Q3Uns64_Write(TQ3Uns64 data, TQ3FileObject theFile)
1698 {
1699
1700
1701 // Release build checks
1702 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1703
1704
1705
1706 // Debug build checks
1707 #if Q3_DEBUG
1708 if (0) // Further checks on data
1709 return(kQ3Failure);
1710
1711 if (0) // Further checks on theFile
1712 return(kQ3Failure);
1713 #endif
1714
1715
1716
1717 // Call the bottleneck
1718 E3System_Bottleneck();
1719
1720
1721
1722 // Call our implementation
1723 return(E3Uns64_Write(data, (E3File*) theFile ));
1724 }
1725
1726
1727
1728
1729
1730 //=============================================================================
1731 // Q3Int64_Read : Quesa API entry point.
1732 //-----------------------------------------------------------------------------
1733 TQ3Status
Q3Int64_Read(TQ3Int64 * data,TQ3FileObject theFile)1734 Q3Int64_Read(TQ3Int64 *data, TQ3FileObject theFile)
1735 {
1736
1737
1738 // Release build checks
1739 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1740 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1741
1742
1743
1744 // Debug build checks
1745 #if Q3_DEBUG
1746 if (0) // Further checks on data
1747 return(kQ3Failure);
1748
1749 if (0) // Further checks on theFile
1750 return(kQ3Failure);
1751 #endif
1752
1753
1754
1755 // Call the bottleneck
1756 E3System_Bottleneck();
1757
1758
1759
1760 // Call our implementation
1761 return(E3Int64_Read(data, (E3File*) theFile ));
1762 }
1763
1764
1765
1766
1767
1768 //=============================================================================
1769 // Q3Int64_Write : Quesa API entry point.
1770 //-----------------------------------------------------------------------------
1771 TQ3Status
Q3Int64_Write(TQ3Int64 data,TQ3FileObject theFile)1772 Q3Int64_Write(TQ3Int64 data, TQ3FileObject theFile)
1773 {
1774
1775
1776 // Release build checks
1777 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1778
1779
1780
1781 // Debug build checks
1782 #if Q3_DEBUG
1783 if (0) // Further checks on data
1784 return(kQ3Failure);
1785
1786 if (0) // Further checks on theFile
1787 return(kQ3Failure);
1788 #endif
1789
1790
1791
1792 // Call the bottleneck
1793 E3System_Bottleneck();
1794
1795
1796
1797 // Call our implementation
1798 return(E3Int64_Write(data, (E3File*) theFile ));
1799 }
1800
1801
1802
1803
1804
1805 //=============================================================================
1806 // Q3Float32_Read : Quesa API entry point.
1807 //-----------------------------------------------------------------------------
1808 TQ3Status
Q3Float32_Read(TQ3Float32 * data,TQ3FileObject theFile)1809 Q3Float32_Read(TQ3Float32 *data, TQ3FileObject theFile)
1810 {
1811
1812
1813 // Release build checks
1814 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1815 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1816
1817
1818
1819 // Debug build checks
1820 #if Q3_DEBUG
1821 if (0) // Further checks on data
1822 return(kQ3Failure);
1823
1824 if (0) // Further checks on theFile
1825 return(kQ3Failure);
1826 #endif
1827
1828
1829
1830 // Call the bottleneck
1831 E3System_Bottleneck();
1832
1833
1834
1835 // Call our implementation
1836 return(E3Float32_Read(data, (E3File*) theFile ));
1837 }
1838
1839
1840
1841
1842
1843 //=============================================================================
1844 // Q3Float32_ReadArray : Quesa API entry point.
1845 //-----------------------------------------------------------------------------
1846 TQ3Status
Q3Float32_ReadArray(TQ3Uns32 numFloats,TQ3Float32 * floatArray,TQ3FileObject theFile)1847 Q3Float32_ReadArray (
1848 TQ3Uns32 numFloats,
1849 TQ3Float32* floatArray,
1850 TQ3FileObject theFile
1851 )
1852 {
1853 // Release build checks
1854 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(floatArray), kQ3Failure);
1855 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1856
1857
1858
1859 // Call the bottleneck
1860 E3System_Bottleneck();
1861
1862
1863
1864 // Call our implementation
1865 return (E3Float32_ReadArray( numFloats, floatArray, (E3File*) theFile ));
1866 }
1867
1868
1869
1870
1871
1872 //=============================================================================
1873 // Q3Float32_Write : Quesa API entry point.
1874 //-----------------------------------------------------------------------------
1875 TQ3Status
Q3Float32_Write(TQ3Float32 data,TQ3FileObject theFile)1876 Q3Float32_Write(TQ3Float32 data, TQ3FileObject theFile)
1877 {
1878
1879
1880 // Release build checks
1881 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1882
1883
1884
1885 // Debug build checks
1886 #if Q3_DEBUG
1887 if (0) // Further checks on data
1888 return(kQ3Failure);
1889
1890 if (0) // Further checks on theFile
1891 return(kQ3Failure);
1892 #endif
1893
1894
1895
1896 // Call the bottleneck
1897 E3System_Bottleneck();
1898
1899
1900
1901 // Call our implementation
1902 return(E3Float32_Write(data, (E3File*) theFile ));
1903 }
1904
1905
1906
1907
1908
1909 //=============================================================================
1910 // Q3Float64_Read : Quesa API entry point.
1911 //-----------------------------------------------------------------------------
1912 TQ3Status
Q3Float64_Read(TQ3Float64 * data,TQ3FileObject theFile)1913 Q3Float64_Read(TQ3Float64 *data, TQ3FileObject theFile)
1914 {
1915
1916
1917 // Release build checks
1918 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
1919 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1920
1921
1922
1923 // Debug build checks
1924 #if Q3_DEBUG
1925 if (0) // Further checks on data
1926 return(kQ3Failure);
1927
1928 if (0) // Further checks on theFile
1929 return(kQ3Failure);
1930 #endif
1931
1932
1933
1934 // Call the bottleneck
1935 E3System_Bottleneck();
1936
1937
1938
1939 // Call our implementation
1940 return(E3Float64_Read(data, (E3File*) theFile ));
1941 }
1942
1943
1944
1945
1946
1947 //=============================================================================
1948 // Q3Float64_Write : Quesa API entry point.
1949 //-----------------------------------------------------------------------------
1950 TQ3Status
Q3Float64_Write(TQ3Float64 data,TQ3FileObject theFile)1951 Q3Float64_Write(TQ3Float64 data, TQ3FileObject theFile)
1952 {
1953
1954
1955 // Release build checks
1956 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
1957
1958
1959
1960 // Debug build checks
1961 #if Q3_DEBUG
1962 if (0) // Further checks on data
1963 return(kQ3Failure);
1964
1965 if (0) // Further checks on theFile
1966 return(kQ3Failure);
1967 #endif
1968
1969
1970
1971 // Call the bottleneck
1972 E3System_Bottleneck();
1973
1974
1975
1976 // Call our implementation
1977 return(E3Float64_Write(data, (E3File*) theFile ));
1978 }
1979
1980
1981
1982
1983
1984 //=============================================================================
1985 // Q3Size_Pad : Quesa API entry point.
1986 //-----------------------------------------------------------------------------
1987 TQ3Size
Q3Size_Pad(TQ3Size size)1988 Q3Size_Pad(TQ3Size size)
1989 {
1990
1991
1992 // Release build checks
1993
1994
1995
1996 // Debug build checks
1997 #if Q3_DEBUG
1998 if (0) // Further checks on size
1999 return(size);
2000 #endif
2001
2002
2003
2004 // Call the bottleneck
2005 E3System_Bottleneck();
2006
2007
2008
2009 // Call our implementation
2010 return(E3Size_Pad(size));
2011 }
2012
2013
2014
2015
2016
2017 //=============================================================================
2018 // Q3String_Read : Quesa API entry point.
2019 //-----------------------------------------------------------------------------
2020 TQ3Status
Q3String_Read(char * data,TQ3Uns32 * length,TQ3FileObject theFile)2021 Q3String_Read(char *data, TQ3Uns32 *length, TQ3FileObject theFile)
2022 {
2023
2024
2025 // Release build checks
2026 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(length), kQ3Failure);
2027 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2028
2029
2030
2031 // Debug build checks
2032 #if Q3_DEBUG
2033 if (0) // Further checks on data
2034 return(kQ3Failure);
2035
2036 if (0) // Further checks on length
2037 return(kQ3Failure);
2038
2039 if (0) // Further checks on theFile
2040 return(kQ3Failure);
2041 #endif
2042
2043
2044
2045 // Call the bottleneck
2046 E3System_Bottleneck();
2047
2048
2049
2050 // Call our implementation
2051 return(E3String_Read(data, length, (E3File*) theFile ));
2052 }
2053
2054
2055
2056
2057
2058 //=============================================================================
2059 // Q3String_ReadUnlimited : Quesa API entry point.
2060 //-----------------------------------------------------------------------------
2061 #if QUESA_ALLOW_QD3D_EXTENSIONS
2062 TQ3Status
Q3String_ReadUnlimited(char * data,TQ3Uns32 * ioLength,TQ3FileObject theFile)2063 Q3String_ReadUnlimited(char *data, TQ3Uns32 *ioLength, TQ3FileObject theFile)
2064 {
2065
2066
2067 // Release build checks
2068 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(ioLength), kQ3Failure);
2069 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2070
2071
2072
2073 // Debug build checks
2074 #if Q3_DEBUG
2075 if (0) // Further checks on data
2076 return(kQ3Failure);
2077
2078 if (0) // Further checks on length
2079 return(kQ3Failure);
2080
2081 if (0) // Further checks on theFile
2082 return(kQ3Failure);
2083 #endif
2084
2085
2086
2087 // Call the bottleneck
2088 E3System_Bottleneck();
2089
2090
2091
2092 // Call our implementation
2093 return(E3String_ReadUnlimited(data, ioLength, (E3File*) theFile ));
2094 }
2095 #endif
2096
2097
2098
2099
2100
2101 //=============================================================================
2102 // Q3String_Write : Quesa API entry point.
2103 //-----------------------------------------------------------------------------
2104 TQ3Status
Q3String_Write(const char * data,TQ3FileObject theFile)2105 Q3String_Write(const char *data, TQ3FileObject theFile)
2106 {
2107
2108
2109 // Release build checks
2110 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
2111 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2112
2113
2114
2115 // Debug build checks
2116 #if Q3_DEBUG
2117 if (0) // Further checks on data
2118 return(kQ3Failure);
2119
2120 if (0) // Further checks on theFile
2121 return(kQ3Failure);
2122 #endif
2123
2124
2125
2126 // Call the bottleneck
2127 E3System_Bottleneck();
2128
2129
2130
2131 // Call our implementation
2132 return(E3String_Write(data, (E3File*) theFile ));
2133 }
2134
2135
2136
2137
2138 //=============================================================================
2139 // Q3String_WriteUnlimited : Quesa API entry point.
2140 //-----------------------------------------------------------------------------
2141 #if QUESA_ALLOW_QD3D_EXTENSIONS
2142 TQ3Status
Q3String_WriteUnlimited(const char * data,TQ3FileObject theFile)2143 Q3String_WriteUnlimited(const char *data, TQ3FileObject theFile)
2144 {
2145
2146
2147 // Release build checks
2148 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
2149 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2150
2151
2152
2153 // Debug build checks
2154 #if Q3_DEBUG
2155 if (0) // Further checks on data
2156 return(kQ3Failure);
2157
2158 if (0) // Further checks on theFile
2159 return(kQ3Failure);
2160 #endif
2161
2162
2163
2164 // Call the bottleneck
2165 E3System_Bottleneck();
2166
2167
2168
2169 // Call our implementation
2170 return (E3String_WriteUnlimited(data, (E3File*) theFile ));
2171 }
2172 #endif
2173
2174
2175
2176
2177 //=============================================================================
2178 // Q3RawData_Read : Quesa API entry point.
2179 //-----------------------------------------------------------------------------
2180 TQ3Status
Q3RawData_Read(unsigned char * data,TQ3Uns32 size,TQ3FileObject theFile)2181 Q3RawData_Read(unsigned char *data, TQ3Uns32 size, TQ3FileObject theFile)
2182 {
2183
2184
2185 // Release build checks
2186 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
2187 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2188
2189
2190
2191 // Debug build checks
2192 #if Q3_DEBUG
2193 if (0) // Further checks on data
2194 return(kQ3Failure);
2195
2196 if (0) // Further checks on size
2197 return(kQ3Failure);
2198
2199 if (0) // Further checks on theFile
2200 return(kQ3Failure);
2201 #endif
2202
2203
2204
2205 // Call the bottleneck
2206 E3System_Bottleneck();
2207
2208
2209
2210 // Call our implementation
2211 return(E3RawData_Read(data, size, (E3File*) theFile ));
2212 }
2213
2214
2215
2216
2217
2218 //=============================================================================
2219 // Q3RawData_Write : Quesa API entry point.
2220 //-----------------------------------------------------------------------------
2221 TQ3Status
Q3RawData_Write(const unsigned char * data,TQ3Uns32 size,TQ3FileObject theFile)2222 Q3RawData_Write(const unsigned char *data, TQ3Uns32 size, TQ3FileObject theFile)
2223 {
2224
2225
2226 // Release build checks
2227 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
2228 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2229
2230
2231
2232 // Debug build checks
2233 #if Q3_DEBUG
2234 if (0) // Further checks on data
2235 return(kQ3Failure);
2236
2237 if (0) // Further checks on size
2238 return(kQ3Failure);
2239
2240 if (0) // Further checks on theFile
2241 return(kQ3Failure);
2242 #endif
2243
2244
2245
2246 // Call the bottleneck
2247 E3System_Bottleneck();
2248
2249
2250
2251 // Call our implementation
2252 return(E3RawData_Write(data, size, (E3File*) theFile ));
2253 }
2254
2255
2256
2257
2258
2259 //=============================================================================
2260 // Q3Point2D_Read : Quesa API entry point.
2261 //-----------------------------------------------------------------------------
2262 TQ3Status
Q3Point2D_Read(TQ3Point2D * point2D,TQ3FileObject theFile)2263 Q3Point2D_Read(TQ3Point2D *point2D, TQ3FileObject theFile)
2264 {
2265
2266
2267 // Release build checks
2268 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point2D), kQ3Failure);
2269 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2270
2271
2272
2273 // Debug build checks
2274 #if Q3_DEBUG
2275 if (0) // Further checks on point2D
2276 return(kQ3Failure);
2277
2278 if (0) // Further checks on theFile
2279 return(kQ3Failure);
2280 #endif
2281
2282
2283
2284 // Call the bottleneck
2285 E3System_Bottleneck();
2286
2287
2288
2289 // Call our implementation
2290 return(E3Point2D_Read(point2D, (E3File*) theFile ));
2291 }
2292
2293
2294
2295
2296
2297 //=============================================================================
2298 // Q3Point2D_Write : Quesa API entry point.
2299 //-----------------------------------------------------------------------------
2300 TQ3Status
Q3Point2D_Write(const TQ3Point2D * point2D,TQ3FileObject theFile)2301 Q3Point2D_Write(const TQ3Point2D *point2D, TQ3FileObject theFile)
2302 {
2303
2304
2305 // Release build checks
2306 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point2D), kQ3Failure);
2307 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2308
2309
2310
2311 // Debug build checks
2312 #if Q3_DEBUG
2313 if (0) // Further checks on point2D
2314 return(kQ3Failure);
2315
2316 if (0) // Further checks on theFile
2317 return(kQ3Failure);
2318 #endif
2319
2320
2321
2322 // Call the bottleneck
2323 E3System_Bottleneck();
2324
2325
2326
2327 // Call our implementation
2328 return(E3Point2D_Write(point2D, (E3File*) theFile ));
2329 }
2330
2331
2332
2333
2334
2335 //=============================================================================
2336 // Q3Point3D_Read : Quesa API entry point.
2337 //-----------------------------------------------------------------------------
2338 TQ3Status
Q3Point3D_Read(TQ3Point3D * point3D,TQ3FileObject theFile)2339 Q3Point3D_Read(TQ3Point3D *point3D, TQ3FileObject theFile)
2340 {
2341
2342
2343 // Release build checks
2344 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point3D), kQ3Failure);
2345 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2346
2347
2348
2349 // Debug build checks
2350 #if Q3_DEBUG
2351 if (0) // Further checks on point3D
2352 return(kQ3Failure);
2353
2354 if (0) // Further checks on theFile
2355 return(kQ3Failure);
2356 #endif
2357
2358
2359
2360 // Call the bottleneck
2361 E3System_Bottleneck();
2362
2363
2364
2365 // Call our implementation
2366 return(E3Point3D_Read(point3D, (E3File*) theFile ));
2367 }
2368
2369
2370
2371
2372
2373 //=============================================================================
2374 // Q3Point3D_Write : Quesa API entry point.
2375 //-----------------------------------------------------------------------------
2376 TQ3Status
Q3Point3D_Write(const TQ3Point3D * point3D,TQ3FileObject theFile)2377 Q3Point3D_Write(const TQ3Point3D *point3D, TQ3FileObject theFile)
2378 {
2379
2380
2381 // Release build checks
2382 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point3D), kQ3Failure);
2383 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2384
2385
2386
2387 // Debug build checks
2388 #if Q3_DEBUG
2389 if (0) // Further checks on point3D
2390 return(kQ3Failure);
2391
2392 if (0) // Further checks on theFile
2393 return(kQ3Failure);
2394 #endif
2395
2396
2397
2398 // Call the bottleneck
2399 E3System_Bottleneck();
2400
2401
2402
2403 // Call our implementation
2404 return(E3Point3D_Write(point3D, (E3File*) theFile ));
2405 }
2406
2407
2408
2409
2410
2411 //=============================================================================
2412 // Q3RationalPoint3D_Read : Quesa API entry point.
2413 //-----------------------------------------------------------------------------
2414 TQ3Status
Q3RationalPoint3D_Read(TQ3RationalPoint3D * point3D,TQ3FileObject theFile)2415 Q3RationalPoint3D_Read(TQ3RationalPoint3D *point3D, TQ3FileObject theFile)
2416 {
2417
2418
2419 // Release build checks
2420 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point3D), kQ3Failure);
2421 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2422
2423
2424
2425 // Debug build checks
2426 #if Q3_DEBUG
2427 if (0) // Further checks on point3D
2428 return(kQ3Failure);
2429
2430 if (0) // Further checks on theFile
2431 return(kQ3Failure);
2432 #endif
2433
2434
2435
2436 // Call the bottleneck
2437 E3System_Bottleneck();
2438
2439
2440
2441 // Call our implementation
2442 return(E3RationalPoint3D_Read(point3D, (E3File*) theFile ));
2443 }
2444
2445
2446
2447
2448
2449 //=============================================================================
2450 // Q3RationalPoint3D_Write : Quesa API entry point.
2451 //-----------------------------------------------------------------------------
2452 TQ3Status
Q3RationalPoint3D_Write(const TQ3RationalPoint3D * point3D,TQ3FileObject theFile)2453 Q3RationalPoint3D_Write(const TQ3RationalPoint3D *point3D, TQ3FileObject theFile)
2454 {
2455
2456
2457 // Release build checks
2458 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point3D), kQ3Failure);
2459 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2460
2461
2462
2463 // Debug build checks
2464 #if Q3_DEBUG
2465 if (0) // Further checks on point3D
2466 return(kQ3Failure);
2467
2468 if (0) // Further checks on theFile
2469 return(kQ3Failure);
2470 #endif
2471
2472
2473
2474 // Call the bottleneck
2475 E3System_Bottleneck();
2476
2477
2478
2479 // Call our implementation
2480 return(E3RationalPoint3D_Write(point3D, (E3File*) theFile ));
2481 }
2482
2483
2484
2485
2486
2487 //=============================================================================
2488 // Q3RationalPoint4D_Read : Quesa API entry point.
2489 //-----------------------------------------------------------------------------
2490 TQ3Status
Q3RationalPoint4D_Read(TQ3RationalPoint4D * point4D,TQ3FileObject theFile)2491 Q3RationalPoint4D_Read(TQ3RationalPoint4D *point4D, TQ3FileObject theFile)
2492 {
2493
2494
2495 // Release build checks
2496 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point4D), kQ3Failure);
2497 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2498
2499
2500
2501 // Debug build checks
2502 #if Q3_DEBUG
2503 if (0) // Further checks on point4D
2504 return(kQ3Failure);
2505
2506 if (0) // Further checks on theFile
2507 return(kQ3Failure);
2508 #endif
2509
2510
2511
2512 // Call the bottleneck
2513 E3System_Bottleneck();
2514
2515
2516
2517 // Call our implementation
2518 return(E3RationalPoint4D_Read(point4D, (E3File*) theFile ));
2519 }
2520
2521
2522
2523
2524
2525 //=============================================================================
2526 // Q3RationalPoint4D_Write : Quesa API entry point.
2527 //-----------------------------------------------------------------------------
2528 TQ3Status
Q3RationalPoint4D_Write(const TQ3RationalPoint4D * point4D,TQ3FileObject theFile)2529 Q3RationalPoint4D_Write(const TQ3RationalPoint4D *point4D, TQ3FileObject theFile)
2530 {
2531
2532
2533 // Release build checks
2534 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(point4D), kQ3Failure);
2535 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2536
2537
2538
2539 // Debug build checks
2540 #if Q3_DEBUG
2541 if (0) // Further checks on point4D
2542 return(kQ3Failure);
2543
2544 if (0) // Further checks on theFile
2545 return(kQ3Failure);
2546 #endif
2547
2548
2549
2550 // Call the bottleneck
2551 E3System_Bottleneck();
2552
2553
2554
2555 // Call our implementation
2556 return(E3RationalPoint4D_Write(point4D, (E3File*) theFile ));
2557 }
2558
2559
2560
2561
2562
2563 //=============================================================================
2564 // Q3Vector2D_Read : Quesa API entry point.
2565 //-----------------------------------------------------------------------------
2566 TQ3Status
Q3Vector2D_Read(TQ3Vector2D * vector2D,TQ3FileObject theFile)2567 Q3Vector2D_Read(TQ3Vector2D *vector2D, TQ3FileObject theFile)
2568 {
2569
2570
2571 // Release build checks
2572 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vector2D), kQ3Failure);
2573 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2574
2575
2576
2577 // Debug build checks
2578 #if Q3_DEBUG
2579 if (0) // Further checks on vector2D
2580 return(kQ3Failure);
2581
2582 if (0) // Further checks on theFile
2583 return(kQ3Failure);
2584 #endif
2585
2586
2587
2588 // Call the bottleneck
2589 E3System_Bottleneck();
2590
2591
2592
2593 // Call our implementation
2594 return(E3Vector2D_Read(vector2D, (E3File*) theFile ));
2595 }
2596
2597
2598
2599
2600
2601 //=============================================================================
2602 // Q3Vector2D_Write : Quesa API entry point.
2603 //-----------------------------------------------------------------------------
2604 TQ3Status
Q3Vector2D_Write(const TQ3Vector2D * vector2D,TQ3FileObject theFile)2605 Q3Vector2D_Write(const TQ3Vector2D *vector2D, TQ3FileObject theFile)
2606 {
2607
2608
2609 // Release build checks
2610 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vector2D), kQ3Failure);
2611 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2612
2613
2614
2615 // Debug build checks
2616 #if Q3_DEBUG
2617 if (0) // Further checks on vector2D
2618 return(kQ3Failure);
2619
2620 if (0) // Further checks on theFile
2621 return(kQ3Failure);
2622 #endif
2623
2624
2625
2626 // Call the bottleneck
2627 E3System_Bottleneck();
2628
2629
2630
2631 // Call our implementation
2632 return(E3Vector2D_Write(vector2D, (E3File*) theFile ));
2633 }
2634
2635
2636
2637
2638
2639 //=============================================================================
2640 // Q3Vector3D_Read : Quesa API entry point.
2641 //-----------------------------------------------------------------------------
2642 TQ3Status
Q3Vector3D_Read(TQ3Vector3D * vector3D,TQ3FileObject theFile)2643 Q3Vector3D_Read(TQ3Vector3D *vector3D, TQ3FileObject theFile)
2644 {
2645
2646
2647 // Release build checks
2648 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vector3D), kQ3Failure);
2649 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2650
2651
2652
2653 // Debug build checks
2654 #if Q3_DEBUG
2655 if (0) // Further checks on vector3D
2656 return(kQ3Failure);
2657
2658 if (0) // Further checks on theFile
2659 return(kQ3Failure);
2660 #endif
2661
2662
2663
2664 // Call the bottleneck
2665 E3System_Bottleneck();
2666
2667
2668
2669 // Call our implementation
2670 return(E3Vector3D_Read(vector3D, (E3File*) theFile ));
2671 }
2672
2673
2674
2675
2676
2677 //=============================================================================
2678 // Q3Vector3D_Write : Quesa API entry point.
2679 //-----------------------------------------------------------------------------
2680 TQ3Status
Q3Vector3D_Write(const TQ3Vector3D * vector3D,TQ3FileObject theFile)2681 Q3Vector3D_Write(const TQ3Vector3D *vector3D, TQ3FileObject theFile)
2682 {
2683
2684
2685 // Release build checks
2686 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(vector3D), kQ3Failure);
2687 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2688
2689
2690
2691 // Debug build checks
2692 #if Q3_DEBUG
2693 if (0) // Further checks on vector3D
2694 return(kQ3Failure);
2695
2696 if (0) // Further checks on theFile
2697 return(kQ3Failure);
2698 #endif
2699
2700
2701
2702 // Call the bottleneck
2703 E3System_Bottleneck();
2704
2705
2706
2707 // Call our implementation
2708 return(E3Vector3D_Write(vector3D, (E3File*) theFile ));
2709 }
2710
2711
2712
2713
2714
2715 //=============================================================================
2716 // Q3Matrix4x4_Read : Quesa API entry point.
2717 //-----------------------------------------------------------------------------
2718 TQ3Status
Q3Matrix4x4_Read(TQ3Matrix4x4 * matrix4x4,TQ3FileObject theFile)2719 Q3Matrix4x4_Read(TQ3Matrix4x4 *matrix4x4, TQ3FileObject theFile)
2720 {
2721
2722
2723 // Release build checks
2724 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(matrix4x4), kQ3Failure);
2725 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2726
2727
2728
2729 // Debug build checks
2730 #if Q3_DEBUG
2731 if (0) // Further checks on matrix4x4
2732 return(kQ3Failure);
2733
2734 if (0) // Further checks on theFile
2735 return(kQ3Failure);
2736 #endif
2737
2738
2739
2740 // Call the bottleneck
2741 E3System_Bottleneck();
2742
2743
2744
2745 // Call our implementation
2746 return(E3Matrix4x4_Read(matrix4x4, (E3File*) theFile ));
2747 }
2748
2749
2750
2751
2752
2753 //=============================================================================
2754 // Q3Matrix4x4_Write : Quesa API entry point.
2755 //-----------------------------------------------------------------------------
2756 TQ3Status
Q3Matrix4x4_Write(const TQ3Matrix4x4 * matrix4x4,TQ3FileObject theFile)2757 Q3Matrix4x4_Write(const TQ3Matrix4x4 *matrix4x4, TQ3FileObject theFile)
2758 {
2759
2760
2761 // Release build checks
2762 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(matrix4x4), kQ3Failure);
2763 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2764
2765
2766
2767 // Debug build checks
2768 #if Q3_DEBUG
2769 if (0) // Further checks on matrix4x4
2770 return(kQ3Failure);
2771
2772 if (0) // Further checks on theFile
2773 return(kQ3Failure);
2774 #endif
2775
2776
2777
2778 // Call the bottleneck
2779 E3System_Bottleneck();
2780
2781
2782
2783 // Call our implementation
2784 return(E3Matrix4x4_Write(matrix4x4, (E3File*) theFile ));
2785 }
2786
2787
2788
2789
2790
2791 //=============================================================================
2792 // Q3Tangent2D_Read : Quesa API entry point.
2793 //-----------------------------------------------------------------------------
2794 TQ3Status
Q3Tangent2D_Read(TQ3Tangent2D * tangent2D,TQ3FileObject theFile)2795 Q3Tangent2D_Read(TQ3Tangent2D *tangent2D, TQ3FileObject theFile)
2796 {
2797
2798
2799 // Release build checks
2800 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(tangent2D), kQ3Failure);
2801 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2802
2803
2804
2805 // Debug build checks
2806 #if Q3_DEBUG
2807 if (0) // Further checks on tangent2D
2808 return(kQ3Failure);
2809
2810 if (0) // Further checks on theFile
2811 return(kQ3Failure);
2812 #endif
2813
2814
2815
2816 // Call the bottleneck
2817 E3System_Bottleneck();
2818
2819
2820
2821 // Call our implementation
2822 return(E3Tangent2D_Read(tangent2D, (E3File*) theFile ));
2823 }
2824
2825
2826
2827
2828
2829 //=============================================================================
2830 // Q3Tangent2D_Write : Quesa API entry point.
2831 //-----------------------------------------------------------------------------
2832 TQ3Status
Q3Tangent2D_Write(const TQ3Tangent2D * tangent2D,TQ3FileObject theFile)2833 Q3Tangent2D_Write(const TQ3Tangent2D *tangent2D, TQ3FileObject theFile)
2834 {
2835
2836
2837 // Release build checks
2838 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(tangent2D), kQ3Failure);
2839 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2840
2841
2842
2843 // Debug build checks
2844 #if Q3_DEBUG
2845 if (0) // Further checks on tangent2D
2846 return(kQ3Failure);
2847
2848 if (0) // Further checks on theFile
2849 return(kQ3Failure);
2850 #endif
2851
2852
2853
2854 // Call the bottleneck
2855 E3System_Bottleneck();
2856
2857
2858
2859 // Call our implementation
2860 return(E3Tangent2D_Write(tangent2D, (E3File*) theFile ));
2861 }
2862
2863
2864
2865
2866
2867 //=============================================================================
2868 // Q3Tangent3D_Read : Quesa API entry point.
2869 //-----------------------------------------------------------------------------
2870 TQ3Status
Q3Tangent3D_Read(TQ3Tangent3D * tangent3D,TQ3FileObject theFile)2871 Q3Tangent3D_Read(TQ3Tangent3D *tangent3D, TQ3FileObject theFile)
2872 {
2873
2874
2875 // Release build checks
2876 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(tangent3D), kQ3Failure);
2877 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2878
2879
2880
2881 // Debug build checks
2882 #if Q3_DEBUG
2883 if (0) // Further checks on tangent3D
2884 return(kQ3Failure);
2885
2886 if (0) // Further checks on theFile
2887 return(kQ3Failure);
2888 #endif
2889
2890
2891
2892 // Call the bottleneck
2893 E3System_Bottleneck();
2894
2895
2896
2897 // Call our implementation
2898 return(E3Tangent3D_Read(tangent3D, (E3File*) theFile ));
2899 }
2900
2901
2902
2903
2904
2905 //=============================================================================
2906 // Q3Tangent3D_Write : Quesa API entry point.
2907 //-----------------------------------------------------------------------------
2908 TQ3Status
Q3Tangent3D_Write(const TQ3Tangent3D * tangent3D,TQ3FileObject theFile)2909 Q3Tangent3D_Write(const TQ3Tangent3D *tangent3D, TQ3FileObject theFile)
2910 {
2911
2912
2913 // Release build checks
2914 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(tangent3D), kQ3Failure);
2915 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2916
2917
2918
2919 // Debug build checks
2920 #if Q3_DEBUG
2921 if (0) // Further checks on tangent3D
2922 return(kQ3Failure);
2923
2924 if (0) // Further checks on theFile
2925 return(kQ3Failure);
2926 #endif
2927
2928
2929
2930 // Call the bottleneck
2931 E3System_Bottleneck();
2932
2933
2934
2935 // Call our implementation
2936 return(E3Tangent3D_Write(tangent3D, (E3File*) theFile ));
2937 }
2938
2939
2940
2941
2942
2943 //=============================================================================
2944 // Q3Comment_Write : Quesa API entry point.
2945 //-----------------------------------------------------------------------------
2946 TQ3Status
Q3Comment_Write(char * comment,TQ3FileObject theFile)2947 Q3Comment_Write(char *comment, TQ3FileObject theFile)
2948 {
2949
2950
2951 // Release build checks
2952 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(comment), kQ3Failure);
2953 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, (kQ3SharedTypeFile)), kQ3Failure);
2954
2955
2956
2957 // Debug build checks
2958 #if Q3_DEBUG
2959 if (0) // Further checks on comment
2960 return(kQ3Failure);
2961
2962 if (0) // Further checks on theFile
2963 return(kQ3Failure);
2964 #endif
2965
2966
2967
2968 // Call the bottleneck
2969 E3System_Bottleneck();
2970
2971
2972
2973 // Call our implementation
2974 return(E3Comment_Write(comment, (E3File*) theFile ));
2975 }
2976
2977
2978
2979 #pragma mark -
2980
2981 //=============================================================================
2982 // Q3Unknown_GetType : Quesa API entry point.
2983 //-----------------------------------------------------------------------------
2984 TQ3ObjectType
Q3Unknown_GetType(TQ3UnknownObject unknownObject)2985 Q3Unknown_GetType(TQ3UnknownObject unknownObject)
2986 {
2987
2988
2989 // Release build checks
2990 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(unknownObject, kQ3ShapeTypeUnknown), kQ3ObjectTypeInvalid);
2991
2992
2993
2994 // Debug build checks
2995 #if Q3_DEBUG
2996 if (0) // Further checks on unknownObject
2997 return(kQ3ObjectTypeInvalid);
2998 #endif
2999
3000
3001
3002 // Call the bottleneck
3003 E3System_Bottleneck();
3004
3005
3006
3007 // Call our implementation
3008 return(E3Unknown_GetType(unknownObject));
3009 }
3010
3011
3012
3013
3014
3015 //=============================================================================
3016 // Q3Unknown_GetDirtyState : Quesa API entry point.
3017 //-----------------------------------------------------------------------------
3018 TQ3Status
Q3Unknown_GetDirtyState(TQ3UnknownObject unknownObject,TQ3Boolean * isDirty)3019 Q3Unknown_GetDirtyState(TQ3UnknownObject unknownObject, TQ3Boolean *isDirty)
3020 {
3021
3022
3023 // Release build checks
3024 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(unknownObject, (kQ3ShapeTypeUnknown)), kQ3Failure);
3025 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(isDirty), kQ3Failure);
3026
3027
3028
3029 // Debug build checks
3030 #if Q3_DEBUG
3031 if (0) // Further checks on unknownObject
3032 return(kQ3Failure);
3033
3034 if (0) // Further checks on isDirty
3035 return(kQ3Failure);
3036 #endif
3037
3038
3039
3040 // Call the bottleneck
3041 E3System_Bottleneck();
3042
3043
3044
3045 // Call our implementation
3046 return(E3Unknown_GetDirtyState(unknownObject, isDirty));
3047 }
3048
3049
3050
3051
3052
3053 //=============================================================================
3054 // Q3Unknown_SetDirtyState : Quesa API entry point.
3055 //-----------------------------------------------------------------------------
3056 TQ3Status
Q3Unknown_SetDirtyState(TQ3UnknownObject unknownObject,TQ3Boolean isDirty)3057 Q3Unknown_SetDirtyState(TQ3UnknownObject unknownObject, TQ3Boolean isDirty)
3058 {
3059
3060
3061 // Release build checks
3062 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(unknownObject, (kQ3ShapeTypeUnknown)), kQ3Failure);
3063
3064
3065
3066 // Debug build checks
3067 #if Q3_DEBUG
3068 if (0) // Further checks on unknownObject
3069 return(kQ3Failure);
3070
3071 if (0) // Further checks on isDirty
3072 return(kQ3Failure);
3073 #endif
3074
3075
3076
3077 // Call the bottleneck
3078 E3System_Bottleneck();
3079
3080
3081
3082 // Call our implementation
3083 return(E3Unknown_SetDirtyState(unknownObject, isDirty));
3084 }
3085
3086
3087
3088
3089
3090 //=============================================================================
3091 // Q3UnknownText_GetData : Quesa API entry point.
3092 //-----------------------------------------------------------------------------
3093 TQ3Status
Q3UnknownText_GetData(TQ3UnknownObject unknownObject,TQ3UnknownTextData * unknownTextData)3094 Q3UnknownText_GetData(TQ3UnknownObject unknownObject, TQ3UnknownTextData *unknownTextData)
3095 {
3096
3097
3098 // Release build checks
3099 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(unknownObject, (kQ3ShapeTypeUnknown)), kQ3Failure);
3100 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(unknownTextData), kQ3Failure);
3101
3102
3103
3104 // Debug build checks
3105 #if Q3_DEBUG
3106 if (0) // Further checks on unknownObject
3107 return(kQ3Failure);
3108
3109 if (0) // Further checks on unknownTextData
3110 return(kQ3Failure);
3111 #endif
3112
3113
3114
3115 // Call the bottleneck
3116 E3System_Bottleneck();
3117
3118
3119
3120 // Call our implementation
3121 return(E3UnknownText_GetData(unknownObject, unknownTextData));
3122 }
3123
3124
3125
3126
3127
3128 //=============================================================================
3129 // Q3UnknownText_EmptyData : Quesa API entry point.
3130 //-----------------------------------------------------------------------------
3131 TQ3Status
Q3UnknownText_EmptyData(TQ3UnknownTextData * unknownTextData)3132 Q3UnknownText_EmptyData(TQ3UnknownTextData *unknownTextData)
3133 {
3134
3135
3136 // Release build checks
3137 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(unknownTextData), kQ3Failure);
3138
3139
3140
3141 // Debug build checks
3142 #if Q3_DEBUG
3143 if (0) // Further checks on unknownTextData
3144 return(kQ3Failure);
3145 #endif
3146
3147
3148
3149 // Call the bottleneck
3150 E3System_Bottleneck();
3151
3152
3153
3154 // Call our implementation
3155 return(E3UnknownText_EmptyData(unknownTextData));
3156 }
3157
3158
3159 #pragma mark -
3160
3161
3162 //=============================================================================
3163 // Q3UnknownBinary_GetData : Quesa API entry point.
3164 //-----------------------------------------------------------------------------
3165 TQ3Status
Q3UnknownBinary_GetData(TQ3UnknownObject unknownObject,TQ3UnknownBinaryData * unknownBinaryData)3166 Q3UnknownBinary_GetData(TQ3UnknownObject unknownObject, TQ3UnknownBinaryData *unknownBinaryData)
3167 {
3168
3169
3170 // Release build checks
3171 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(unknownObject, (kQ3ShapeTypeUnknown)), kQ3Failure);
3172 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(unknownBinaryData), kQ3Failure);
3173
3174
3175
3176 // Debug build checks
3177 #if Q3_DEBUG
3178 if (0) // Further checks on unknownObject
3179 return(kQ3Failure);
3180
3181 if (0) // Further checks on unknownBinaryData
3182 return(kQ3Failure);
3183 #endif
3184
3185
3186
3187 // Call the bottleneck
3188 E3System_Bottleneck();
3189
3190
3191
3192 // Call our implementation
3193 return(E3UnknownBinary_GetData(unknownObject, unknownBinaryData));
3194 }
3195
3196
3197
3198
3199
3200 //=============================================================================
3201 // Q3UnknownBinary_EmptyData : Quesa API entry point.
3202 //-----------------------------------------------------------------------------
3203 TQ3Status
Q3UnknownBinary_EmptyData(TQ3UnknownBinaryData * unknownBinaryData)3204 Q3UnknownBinary_EmptyData(TQ3UnknownBinaryData *unknownBinaryData)
3205 {
3206
3207
3208 // Release build checks
3209 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(unknownBinaryData), kQ3Failure);
3210
3211
3212
3213 // Debug build checks
3214 #if Q3_DEBUG
3215 if (0) // Further checks on unknownBinaryData
3216 return(kQ3Failure);
3217 #endif
3218
3219
3220
3221 // Call the bottleneck
3222 E3System_Bottleneck();
3223
3224
3225
3226 // Call our implementation
3227 return(E3UnknownBinary_EmptyData(unknownBinaryData));
3228 }
3229
3230
3231
3232
3233
3234 //=============================================================================
3235 // Q3UnknownBinary_GetTypeString : Quesa API entry point.
3236 //-----------------------------------------------------------------------------
3237 TQ3Status
Q3UnknownBinary_GetTypeString(TQ3UnknownObject unknownObject,char ** typeString)3238 Q3UnknownBinary_GetTypeString(TQ3UnknownObject unknownObject, char **typeString)
3239 {
3240
3241
3242 // Release build checks
3243 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(unknownObject, (kQ3ShapeTypeUnknown)), kQ3Failure);
3244 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(typeString), kQ3Failure);
3245
3246
3247
3248 // Debug build checks
3249 #if Q3_DEBUG
3250 if (0) // Further checks on unknownObject
3251 return(kQ3Failure);
3252
3253 if (0) // Further checks on typeString
3254 return(kQ3Failure);
3255 #endif
3256
3257
3258
3259 // Call the bottleneck
3260 E3System_Bottleneck();
3261
3262
3263
3264 // Call our implementation
3265 return(E3UnknownBinary_GetTypeString(unknownObject, typeString));
3266 }
3267
3268
3269
3270
3271
3272 //=============================================================================
3273 // Q3UnknownBinary_EmptyTypeString : Quesa API entry point.
3274 //-----------------------------------------------------------------------------
3275 TQ3Status
Q3UnknownBinary_EmptyTypeString(char ** typeString)3276 Q3UnknownBinary_EmptyTypeString(char **typeString)
3277 {
3278
3279
3280 // Release build checks
3281 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(typeString), kQ3Failure);
3282
3283
3284
3285 // Debug build checks
3286 #if Q3_DEBUG
3287 if (0) // Further checks on typeString
3288 return(kQ3Failure);
3289 #endif
3290
3291
3292
3293 // Call the bottleneck
3294 E3System_Bottleneck();
3295
3296
3297
3298 // Call our implementation
3299 return(E3UnknownBinary_EmptyTypeString(typeString));
3300 }
3301
3302
3303
3304 #pragma mark -
3305
3306 //=============================================================================
3307 // Q3ViewHints_New : Quesa API entry point.
3308 //-----------------------------------------------------------------------------
3309 TQ3ViewHintsObject
Q3ViewHints_New(TQ3ViewObject view)3310 Q3ViewHints_New(TQ3ViewObject view)
3311 {
3312
3313
3314 // Release build checks
3315 Q3_REQUIRE_OR_RESULT( E3View_IsOfMyClass ( view ), NULL);
3316
3317
3318
3319 // Debug build checks
3320 #if Q3_DEBUG
3321 if (0) // Further checks on view
3322 return(NULL);
3323 #endif
3324
3325
3326
3327 // Call the bottleneck
3328 E3System_Bottleneck();
3329
3330
3331
3332 // Call our implementation
3333 return(E3ViewHints_New(view));
3334 }
3335
3336
3337
3338
3339
3340 //=============================================================================
3341 // Q3ViewHints_SetRenderer : Quesa API entry point.
3342 //-----------------------------------------------------------------------------
3343 TQ3Status
Q3ViewHints_SetRenderer(TQ3ViewHintsObject viewHints,TQ3RendererObject renderer)3344 Q3ViewHints_SetRenderer(TQ3ViewHintsObject viewHints, TQ3RendererObject renderer)
3345 {
3346
3347
3348 // Release build checks
3349 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3350 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(renderer, (kQ3SharedTypeRenderer)), kQ3Failure);
3351
3352
3353
3354 // Debug build checks
3355 #if Q3_DEBUG
3356 if (0) // Further checks on viewHints
3357 return(kQ3Failure);
3358
3359 if (0) // Further checks on renderer
3360 return(kQ3Failure);
3361 #endif
3362
3363
3364
3365 // Call the bottleneck
3366 E3System_Bottleneck();
3367
3368
3369
3370 // Call our implementation
3371 return ( (E3ViewHints*) viewHints )->SetRenderer ( renderer ) ;
3372 }
3373
3374
3375
3376
3377
3378 //=============================================================================
3379 // Q3ViewHints_GetRenderer : Quesa API entry point.
3380 //-----------------------------------------------------------------------------
3381 TQ3Status
Q3ViewHints_GetRenderer(TQ3ViewHintsObject viewHints,TQ3RendererObject * renderer)3382 Q3ViewHints_GetRenderer(TQ3ViewHintsObject viewHints, TQ3RendererObject *renderer)
3383 {
3384
3385
3386 // Release build checks
3387 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3388 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(renderer), kQ3Failure);
3389
3390
3391
3392 // Debug build checks
3393 #if Q3_DEBUG
3394 if (0) // Further checks on viewHints
3395 return(kQ3Failure);
3396
3397 if (0) // Further checks on renderer
3398 return(kQ3Failure);
3399 #endif
3400
3401
3402
3403 // Call the bottleneck
3404 E3System_Bottleneck();
3405
3406
3407
3408 // Call our implementation
3409 return ( (E3ViewHints*) viewHints )->GetRenderer ( renderer ) ;
3410 }
3411
3412
3413
3414
3415
3416 //=============================================================================
3417 // Q3ViewHints_SetCamera : Quesa API entry point.
3418 //-----------------------------------------------------------------------------
3419 TQ3Status
Q3ViewHints_SetCamera(TQ3ViewHintsObject viewHints,TQ3CameraObject camera)3420 Q3ViewHints_SetCamera(TQ3ViewHintsObject viewHints, TQ3CameraObject camera)
3421 {
3422
3423
3424 // Release build checks
3425 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3426 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(camera, (kQ3ShapeTypeCamera)), kQ3Failure);
3427
3428
3429
3430 // Debug build checks
3431 #if Q3_DEBUG
3432 if (0) // Further checks on viewHints
3433 return(kQ3Failure);
3434
3435 if (0) // Further checks on camera
3436 return(kQ3Failure);
3437 #endif
3438
3439
3440
3441 // Call the bottleneck
3442 E3System_Bottleneck();
3443
3444
3445
3446 // Call our implementation
3447 return ( (E3ViewHints*) viewHints )->SetCamera ( camera ) ;
3448 }
3449
3450
3451
3452
3453
3454 //=============================================================================
3455 // Q3ViewHints_GetCamera : Quesa API entry point.
3456 //-----------------------------------------------------------------------------
3457 TQ3Status
Q3ViewHints_GetCamera(TQ3ViewHintsObject viewHints,TQ3CameraObject * camera)3458 Q3ViewHints_GetCamera(TQ3ViewHintsObject viewHints, TQ3CameraObject *camera)
3459 {
3460
3461
3462 // Release build checks
3463 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3464 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(camera), kQ3Failure);
3465
3466
3467
3468 // Debug build checks
3469 #if Q3_DEBUG
3470 if (0) // Further checks on viewHints
3471 return(kQ3Failure);
3472
3473 if (0) // Further checks on camera
3474 return(kQ3Failure);
3475 #endif
3476
3477
3478
3479 // Call the bottleneck
3480 E3System_Bottleneck();
3481
3482
3483
3484 // Call our implementation
3485 return ( (E3ViewHints*) viewHints )->GetCamera ( camera ) ;
3486 }
3487
3488
3489
3490
3491
3492 //=============================================================================
3493 // Q3ViewHints_SetLightGroup : Quesa API entry point.
3494 //-----------------------------------------------------------------------------
3495 TQ3Status
Q3ViewHints_SetLightGroup(TQ3ViewHintsObject viewHints,TQ3GroupObject lightGroup)3496 Q3ViewHints_SetLightGroup(TQ3ViewHintsObject viewHints, TQ3GroupObject lightGroup)
3497 {
3498
3499
3500 // Release build checks
3501 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3502 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(lightGroup, (kQ3ShapeTypeGroup)), kQ3Failure);
3503
3504
3505
3506 // Debug build checks
3507 #if Q3_DEBUG
3508 if (0) // Further checks on viewHints
3509 return(kQ3Failure);
3510
3511 if (0) // Further checks on lightGroup
3512 return(kQ3Failure);
3513 #endif
3514
3515
3516
3517 // Call the bottleneck
3518 E3System_Bottleneck();
3519
3520
3521
3522 // Call our implementation
3523 return ( (E3ViewHints*) viewHints )->SetLightGroup ( lightGroup ) ;
3524 }
3525
3526
3527
3528
3529
3530 //=============================================================================
3531 // Q3ViewHints_GetLightGroup : Quesa API entry point.
3532 //-----------------------------------------------------------------------------
3533 TQ3Status
Q3ViewHints_GetLightGroup(TQ3ViewHintsObject viewHints,TQ3GroupObject * lightGroup)3534 Q3ViewHints_GetLightGroup(TQ3ViewHintsObject viewHints, TQ3GroupObject *lightGroup)
3535 {
3536
3537
3538 // Release build checks
3539 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3540 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(lightGroup), kQ3Failure);
3541
3542
3543
3544 // Debug build checks
3545 #if Q3_DEBUG
3546 if (0) // Further checks on viewHints
3547 return(kQ3Failure);
3548
3549 if (0) // Further checks on lightGroup
3550 return(kQ3Failure);
3551 #endif
3552
3553
3554
3555 // Call the bottleneck
3556 E3System_Bottleneck();
3557
3558
3559
3560 // Call our implementation
3561 return ( (E3ViewHints*) viewHints )->GetLightGroup ( lightGroup ) ;
3562 }
3563
3564
3565
3566
3567
3568 //=============================================================================
3569 // Q3ViewHints_SetAttributeSet : Quesa API entry point.
3570 //-----------------------------------------------------------------------------
3571 TQ3Status
Q3ViewHints_SetAttributeSet(TQ3ViewHintsObject viewHints,TQ3AttributeSet attributeSet)3572 Q3ViewHints_SetAttributeSet(TQ3ViewHintsObject viewHints, TQ3AttributeSet attributeSet)
3573 {
3574
3575
3576 // Release build checks
3577 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3578
3579
3580
3581 // Debug build checks
3582 #if Q3_DEBUG
3583 if (0) // Further checks on viewHints
3584 return(kQ3Failure);
3585
3586 if (0) // Further checks on attributeSet
3587 return(kQ3Failure);
3588 #endif
3589
3590
3591
3592 // Call the bottleneck
3593 E3System_Bottleneck();
3594
3595
3596
3597 // Call our implementation
3598 return ( (E3ViewHints*) viewHints )->SetAttributeSet ( attributeSet ) ;
3599 }
3600
3601
3602
3603
3604
3605 //=============================================================================
3606 // Q3ViewHints_GetAttributeSet : Quesa API entry point.
3607 //-----------------------------------------------------------------------------
3608 TQ3Status
Q3ViewHints_GetAttributeSet(TQ3ViewHintsObject viewHints,TQ3AttributeSet * attributeSet)3609 Q3ViewHints_GetAttributeSet(TQ3ViewHintsObject viewHints, TQ3AttributeSet *attributeSet)
3610 {
3611
3612
3613 // Release build checks
3614 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3615 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(attributeSet), kQ3Failure);
3616
3617
3618
3619 // Debug build checks
3620 #if Q3_DEBUG
3621 if (0) // Further checks on viewHints
3622 return(kQ3Failure);
3623
3624 if (0) // Further checks on attributeSet
3625 return(kQ3Failure);
3626 #endif
3627
3628
3629
3630 // Call the bottleneck
3631 E3System_Bottleneck();
3632
3633
3634
3635 // Call our implementation
3636 return ( (E3ViewHints*) viewHints )->GetAttributeSet ( attributeSet ) ;
3637 }
3638
3639
3640
3641
3642
3643 //=============================================================================
3644 // Q3ViewHints_SetDimensionsState : Quesa API entry point.
3645 //-----------------------------------------------------------------------------
3646 TQ3Status
Q3ViewHints_SetDimensionsState(TQ3ViewHintsObject viewHints,TQ3Boolean isValid)3647 Q3ViewHints_SetDimensionsState(TQ3ViewHintsObject viewHints, TQ3Boolean isValid)
3648 {
3649
3650
3651 // Release build checks
3652 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3653
3654
3655
3656 // Debug build checks
3657 #if Q3_DEBUG
3658 if (0) // Further checks on viewHints
3659 return(kQ3Failure);
3660
3661 if (0) // Further checks on isValid
3662 return(kQ3Failure);
3663 #endif
3664
3665
3666
3667 // Call the bottleneck
3668 E3System_Bottleneck();
3669
3670
3671
3672 // Call our implementation
3673 return ( (E3ViewHints*) viewHints )->SetDimensionsState ( isValid ) ;
3674 }
3675
3676
3677
3678
3679
3680 //=============================================================================
3681 // Q3ViewHints_GetDimensionsState : Quesa API entry point.
3682 //-----------------------------------------------------------------------------
3683 TQ3Status
Q3ViewHints_GetDimensionsState(TQ3ViewHintsObject viewHints,TQ3Boolean * isValid)3684 Q3ViewHints_GetDimensionsState(TQ3ViewHintsObject viewHints, TQ3Boolean *isValid)
3685 {
3686
3687
3688 // Release build checks
3689 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3690 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(isValid), kQ3Failure);
3691
3692
3693
3694 // Debug build checks
3695 #if Q3_DEBUG
3696 if (0) // Further checks on viewHints
3697 return(kQ3Failure);
3698
3699 if (0) // Further checks on isValid
3700 return(kQ3Failure);
3701 #endif
3702
3703
3704
3705 // Call the bottleneck
3706 E3System_Bottleneck();
3707
3708
3709
3710 // Call our implementation
3711 return ( (E3ViewHints*) viewHints )->GetDimensionsState ( isValid ) ;
3712 }
3713
3714
3715
3716
3717
3718 //=============================================================================
3719 // Q3ViewHints_SetDimensions : Quesa API entry point.
3720 //-----------------------------------------------------------------------------
3721 TQ3Status
Q3ViewHints_SetDimensions(TQ3ViewHintsObject viewHints,TQ3Uns32 width,TQ3Uns32 height)3722 Q3ViewHints_SetDimensions(TQ3ViewHintsObject viewHints, TQ3Uns32 width, TQ3Uns32 height)
3723 {
3724
3725
3726 // Release build checks
3727 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3728
3729
3730
3731 // Debug build checks
3732 #if Q3_DEBUG
3733 if (0) // Further checks on viewHints
3734 return(kQ3Failure);
3735
3736 if (0) // Further checks on width
3737 return(kQ3Failure);
3738
3739 if (0) // Further checks on height
3740 return(kQ3Failure);
3741 #endif
3742
3743
3744
3745 // Call the bottleneck
3746 E3System_Bottleneck();
3747
3748
3749
3750 // Call our implementation
3751 return ( (E3ViewHints*) viewHints )->SetDimensions ( width, height ) ;
3752 }
3753
3754
3755
3756
3757
3758 //=============================================================================
3759 // Q3ViewHints_GetDimensions : Quesa API entry point.
3760 //-----------------------------------------------------------------------------
3761 TQ3Status
Q3ViewHints_GetDimensions(TQ3ViewHintsObject viewHints,TQ3Uns32 * width,TQ3Uns32 * height)3762 Q3ViewHints_GetDimensions(TQ3ViewHintsObject viewHints, TQ3Uns32 *width, TQ3Uns32 *height)
3763 {
3764
3765
3766 // Release build checks
3767 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3768 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(width), kQ3Failure);
3769 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(height), kQ3Failure);
3770
3771
3772
3773 // Debug build checks
3774 #if Q3_DEBUG
3775 if (0) // Further checks on viewHints
3776 return(kQ3Failure);
3777
3778 if (0) // Further checks on width
3779 return(kQ3Failure);
3780
3781 if (0) // Further checks on height
3782 return(kQ3Failure);
3783 #endif
3784
3785
3786
3787 // Call the bottleneck
3788 E3System_Bottleneck();
3789
3790
3791
3792 // Call our implementation
3793 return ( (E3ViewHints*) viewHints )->GetDimensions ( width, height ) ;
3794 }
3795
3796
3797
3798
3799
3800 //=============================================================================
3801 // Q3ViewHints_SetMaskState : Quesa API entry point.
3802 //-----------------------------------------------------------------------------
3803 TQ3Status
Q3ViewHints_SetMaskState(TQ3ViewHintsObject viewHints,TQ3Boolean isValid)3804 Q3ViewHints_SetMaskState(TQ3ViewHintsObject viewHints, TQ3Boolean isValid)
3805 {
3806
3807
3808 // Release build checks
3809 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3810
3811
3812
3813 // Debug build checks
3814 #if Q3_DEBUG
3815 if (0) // Further checks on viewHints
3816 return(kQ3Failure);
3817
3818 if (0) // Further checks on isValid
3819 return(kQ3Failure);
3820 #endif
3821
3822
3823
3824 // Call the bottleneck
3825 E3System_Bottleneck();
3826
3827
3828
3829 // Call our implementation
3830 return ( (E3ViewHints*) viewHints )->SetMaskState ( isValid ) ;
3831 }
3832
3833
3834
3835
3836
3837 //=============================================================================
3838 // Q3ViewHints_GetMaskState : Quesa API entry point.
3839 //-----------------------------------------------------------------------------
3840 TQ3Status
Q3ViewHints_GetMaskState(TQ3ViewHintsObject viewHints,TQ3Boolean * isValid)3841 Q3ViewHints_GetMaskState(TQ3ViewHintsObject viewHints, TQ3Boolean *isValid)
3842 {
3843
3844
3845 // Release build checks
3846 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3847 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(isValid), kQ3Failure);
3848
3849
3850
3851 // Debug build checks
3852 #if Q3_DEBUG
3853 if (0) // Further checks on viewHints
3854 return(kQ3Failure);
3855
3856 if (0) // Further checks on isValid
3857 return(kQ3Failure);
3858 #endif
3859
3860
3861
3862 // Call the bottleneck
3863 E3System_Bottleneck();
3864
3865
3866
3867 // Call our implementation
3868 return ( (E3ViewHints*) viewHints )->GetMaskState ( isValid ) ;
3869 }
3870
3871
3872
3873
3874
3875 //=============================================================================
3876 // Q3ViewHints_SetMask : Quesa API entry point.
3877 //-----------------------------------------------------------------------------
3878 TQ3Status
Q3ViewHints_SetMask(TQ3ViewHintsObject viewHints,const TQ3Bitmap * mask)3879 Q3ViewHints_SetMask(TQ3ViewHintsObject viewHints, const TQ3Bitmap *mask)
3880 {
3881
3882
3883 // Release build checks
3884 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3885 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(mask), kQ3Failure);
3886
3887
3888
3889 // Debug build checks
3890 #if Q3_DEBUG
3891 if (0) // Further checks on viewHints
3892 return(kQ3Failure);
3893
3894 if (0) // Further checks on mask
3895 return(kQ3Failure);
3896 #endif
3897
3898
3899
3900 // Call the bottleneck
3901 E3System_Bottleneck();
3902
3903
3904
3905 // Call our implementation
3906 return ( (E3ViewHints*) viewHints )->SetMask ( mask ) ;
3907 }
3908
3909
3910
3911
3912
3913 //=============================================================================
3914 // Q3ViewHints_GetMask : Quesa API entry point.
3915 //-----------------------------------------------------------------------------
3916 TQ3Status
Q3ViewHints_GetMask(TQ3ViewHintsObject viewHints,TQ3Bitmap * mask)3917 Q3ViewHints_GetMask(TQ3ViewHintsObject viewHints, TQ3Bitmap *mask)
3918 {
3919
3920
3921 // Release build checks
3922 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3923 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(mask), kQ3Failure);
3924
3925
3926
3927 // Debug build checks
3928 #if Q3_DEBUG
3929 if (0) // Further checks on viewHints
3930 return(kQ3Failure);
3931
3932 if (0) // Further checks on mask
3933 return(kQ3Failure);
3934 #endif
3935
3936
3937
3938 // Call the bottleneck
3939 E3System_Bottleneck();
3940
3941
3942
3943 // Call our implementation
3944 return ( (E3ViewHints*) viewHints )->GetMask ( mask ) ;
3945 }
3946
3947
3948
3949
3950
3951 //=============================================================================
3952 // Q3ViewHints_SetClearImageMethod : Quesa API entry point.
3953 //-----------------------------------------------------------------------------
3954 TQ3Status
Q3ViewHints_SetClearImageMethod(TQ3ViewHintsObject viewHints,TQ3DrawContextClearImageMethod clearMethod)3955 Q3ViewHints_SetClearImageMethod(TQ3ViewHintsObject viewHints, TQ3DrawContextClearImageMethod clearMethod)
3956 {
3957
3958
3959 // Release build checks
3960 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3961
3962
3963
3964 // Debug build checks
3965 #if Q3_DEBUG
3966 if (0) // Further checks on viewHints
3967 return(kQ3Failure);
3968
3969 if (0) // Further checks on clearMethod
3970 return(kQ3Failure);
3971 #endif
3972
3973
3974
3975 // Call the bottleneck
3976 E3System_Bottleneck();
3977
3978
3979
3980 // Call our implementation
3981 return ( (E3ViewHints*) viewHints )->SetClearImageMethod ( clearMethod ) ;
3982 }
3983
3984
3985
3986
3987
3988 //=============================================================================
3989 // Q3ViewHints_GetClearImageMethod : Quesa API entry point.
3990 //-----------------------------------------------------------------------------
3991 TQ3Status
Q3ViewHints_GetClearImageMethod(TQ3ViewHintsObject viewHints,TQ3DrawContextClearImageMethod * clearMethod)3992 Q3ViewHints_GetClearImageMethod(TQ3ViewHintsObject viewHints, TQ3DrawContextClearImageMethod *clearMethod)
3993 {
3994
3995
3996 // Release build checks
3997 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
3998 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(clearMethod), kQ3Failure);
3999
4000
4001
4002 // Debug build checks
4003 #if Q3_DEBUG
4004 if (0) // Further checks on viewHints
4005 return(kQ3Failure);
4006
4007 if (0) // Further checks on clearMethod
4008 return(kQ3Failure);
4009 #endif
4010
4011
4012
4013 // Call the bottleneck
4014 E3System_Bottleneck();
4015
4016
4017
4018 // Call our implementation
4019 return ( (E3ViewHints*) viewHints )->GetClearImageMethod ( clearMethod ) ;
4020 }
4021
4022
4023
4024
4025
4026 //=============================================================================
4027 // Q3ViewHints_SetClearImageColor : Quesa API entry point.
4028 //-----------------------------------------------------------------------------
4029 TQ3Status
Q3ViewHints_SetClearImageColor(TQ3ViewHintsObject viewHints,const TQ3ColorARGB * color)4030 Q3ViewHints_SetClearImageColor(TQ3ViewHintsObject viewHints, const TQ3ColorARGB *color)
4031 {
4032
4033
4034 // Release build checks
4035 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
4036 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(color), kQ3Failure);
4037
4038
4039
4040 // Debug build checks
4041 #if Q3_DEBUG
4042 if (0) // Further checks on viewHints
4043 return(kQ3Failure);
4044
4045 if (0) // Further checks on color
4046 return(kQ3Failure);
4047 #endif
4048
4049
4050
4051 // Call the bottleneck
4052 E3System_Bottleneck();
4053
4054
4055
4056 // Call our implementation
4057 return ( (E3ViewHints*) viewHints )->SetClearImageColor ( color ) ;
4058 }
4059
4060
4061
4062
4063
4064 //=============================================================================
4065 // Q3ViewHints_GetClearImageColor : Quesa API entry point.
4066 //-----------------------------------------------------------------------------
4067 TQ3Status
Q3ViewHints_GetClearImageColor(TQ3ViewHintsObject viewHints,TQ3ColorARGB * color)4068 Q3ViewHints_GetClearImageColor(TQ3ViewHintsObject viewHints, TQ3ColorARGB *color)
4069 {
4070
4071
4072 // Release build checks
4073 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(viewHints, (kQ3SharedTypeViewHints)), kQ3Failure);
4074 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(color), kQ3Failure);
4075
4076
4077
4078 // Debug build checks
4079 #if Q3_DEBUG
4080 if (0) // Further checks on viewHints
4081 return(kQ3Failure);
4082
4083 if (0) // Further checks on color
4084 return(kQ3Failure);
4085 #endif
4086
4087
4088
4089 // Call the bottleneck
4090 E3System_Bottleneck();
4091
4092
4093
4094 // Call our implementation
4095 return ( (E3ViewHints*) viewHints )->GetClearImageColor ( color ) ;
4096 }
4097
4098
4099
4100
4101
4102 //=============================================================================
4103 // Q3File_GetFileFormat : Quesa API entry point.
4104 //-----------------------------------------------------------------------------
4105 #pragma mark -
4106 TQ3FileFormatObject
Q3File_GetFileFormat(TQ3FileObject theFile)4107 Q3File_GetFileFormat(TQ3FileObject theFile)
4108 {
4109
4110
4111 // Release build checks
4112 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(theFile, kQ3SharedTypeFile), NULL);
4113
4114
4115
4116 // Debug build checks
4117 #if Q3_DEBUG
4118 if (0) // Further checks on theFile
4119 return(NULL);
4120 #endif
4121
4122
4123
4124 // Call the bottleneck
4125 E3System_Bottleneck();
4126
4127
4128
4129 // Call our implementation
4130 return ( (E3File*) theFile )->GetFileFormat () ;
4131
4132 }
4133
4134
4135
4136
4137
4138 //=============================================================================
4139 // Q3FileFormat_NewFromType : Quesa API entry point.
4140 //-----------------------------------------------------------------------------
4141 TQ3FileFormatObject
Q3FileFormat_NewFromType(TQ3ObjectType fformatObjectType)4142 Q3FileFormat_NewFromType(TQ3ObjectType fformatObjectType)
4143 {
4144
4145
4146 // Release build checks
4147 Q3_REQUIRE_OR_RESULT(fformatObjectType != kQ3ObjectTypeInvalid, NULL);
4148
4149
4150
4151 // Debug build checks
4152 #if Q3_DEBUG
4153 if (0) // Further checks on fformatObjectType
4154 return(NULL);
4155 #endif
4156
4157
4158
4159 // Call the bottleneck
4160 E3System_Bottleneck();
4161
4162
4163
4164 // Call our implementation
4165 return(E3FileFormat_NewFromType(fformatObjectType));
4166 }
4167
4168
4169 //=============================================================================
4170 // Q3FileFormat_GetType : Quesa API entry point.
4171 //-----------------------------------------------------------------------------
4172 TQ3ObjectType
Q3FileFormat_GetType(TQ3FileFormatObject format)4173 Q3FileFormat_GetType(TQ3FileFormatObject format)
4174 {
4175
4176
4177 // Release build checks
4178 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, kQ3ObjectTypeFileFormat), kQ3ObjectTypeInvalid);
4179
4180
4181
4182 // Debug build checks
4183 #if Q3_DEBUG
4184 if (0) // Further checks on format
4185 return(kQ3ObjectTypeInvalid);
4186 #endif
4187
4188
4189
4190 // Call the bottleneck
4191 E3System_Bottleneck();
4192
4193
4194
4195 // Call our implementation
4196 return(E3FileFormat_GetType(format));
4197 }
4198
4199
4200
4201
4202
4203 //=============================================================================
4204 // Q3FileFormat_HasModalConfigure : Quesa API entry point.
4205 //-----------------------------------------------------------------------------
4206 TQ3Boolean
Q3FileFormat_HasModalConfigure(TQ3FileFormatObject format)4207 Q3FileFormat_HasModalConfigure(TQ3FileFormatObject format)
4208 {
4209
4210
4211 // Release build checks
4212 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, kQ3ObjectTypeFileFormat), kQ3False);
4213
4214
4215
4216 // Debug build checks
4217 #if Q3_DEBUG
4218 if (0) // Further checks on format
4219 return(kQ3False);
4220 #endif
4221
4222
4223
4224 // Call the bottleneck
4225 E3System_Bottleneck();
4226
4227
4228
4229 // Call our implementation
4230 return(E3FileFormat_HasModalConfigure(format));
4231 }
4232
4233
4234
4235
4236
4237 //=============================================================================
4238 // Q3FileFormat_ModalConfigure : Quesa API entry point.
4239 //-----------------------------------------------------------------------------
4240 TQ3Status
Q3FileFormat_ModalConfigure(TQ3FileFormatObject format,TQ3DialogAnchor dialogAnchor,TQ3Boolean * canceled)4241 Q3FileFormat_ModalConfigure(TQ3FileFormatObject format, TQ3DialogAnchor dialogAnchor, TQ3Boolean *canceled)
4242 {
4243
4244
4245 // Release build checks
4246 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4247 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(canceled), kQ3Failure);
4248
4249
4250
4251 // Debug build checks
4252 #if Q3_DEBUG
4253 if (0) // Further checks on renderer
4254 return(kQ3Failure);
4255
4256 if (0) // Further checks on dialogAnchor
4257 return(kQ3Failure);
4258
4259 if (0) // Further checks on canceled
4260 return(kQ3Failure);
4261 #endif
4262
4263
4264
4265 // Call the bottleneck
4266 E3System_Bottleneck();
4267
4268
4269
4270 // Call our implementation
4271 return(E3FileFormat_ModalConfigure(format, dialogAnchor, canceled));
4272 }
4273
4274
4275
4276
4277
4278 //=============================================================================
4279 // Q3FileFormatClass_GetFormatNameString : Quesa API entry point.
4280 //-----------------------------------------------------------------------------
4281 TQ3Status
Q3FileFormatClass_GetFormatNameString(TQ3ObjectType formatClassType,TQ3ObjectClassNameString formatClassString)4282 Q3FileFormatClass_GetFormatNameString(TQ3ObjectType formatClassType, TQ3ObjectClassNameString formatClassString)
4283 {
4284
4285
4286 // Release build checks
4287
4288
4289
4290 // Debug build checks
4291 #if Q3_DEBUG
4292 if (0) // Further checks on rendererClassType
4293 return(kQ3Failure);
4294
4295 if (0) // Further checks on rendererClassString
4296 return(kQ3Failure);
4297 #endif
4298
4299
4300
4301 // Call the bottleneck
4302 E3System_Bottleneck();
4303
4304
4305
4306 // Call our implementation
4307 return(E3FileFormatClass_GetFormatNameString(formatClassType, formatClassString));
4308 }
4309
4310
4311
4312
4313
4314 //=============================================================================
4315 // Q3FileFormat_GetConfigurationData : Quesa API entry point.
4316 //-----------------------------------------------------------------------------
4317 TQ3Status
Q3FileFormat_GetConfigurationData(TQ3FileFormatObject format,unsigned char * dataBuffer,TQ3Uns32 bufferSize,TQ3Uns32 * actualDataSize)4318 Q3FileFormat_GetConfigurationData(TQ3FileFormatObject format, unsigned char *dataBuffer, TQ3Uns32 bufferSize, TQ3Uns32 *actualDataSize)
4319 {
4320
4321
4322 // Release build checks
4323 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4324 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(dataBuffer), kQ3Failure);
4325 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(actualDataSize), kQ3Failure);
4326
4327
4328
4329 // Debug build checks
4330 #if Q3_DEBUG
4331 if (0) // Further checks on renderer
4332 return(kQ3Failure);
4333
4334 if (0) // Further checks on dataBuffer
4335 return(kQ3Failure);
4336
4337 if (0) // Further checks on bufferSize
4338 return(kQ3Failure);
4339
4340 if (0) // Further checks on actualDataSize
4341 return(kQ3Failure);
4342 #endif
4343
4344
4345
4346 // Call the bottleneck
4347 E3System_Bottleneck();
4348
4349
4350
4351 // Call our implementation
4352 return(E3FileFormat_GetConfigurationData(format, dataBuffer, bufferSize, actualDataSize));
4353 }
4354
4355
4356
4357
4358
4359 //=============================================================================
4360 // Q3FileFormat_SetConfigurationData : Quesa API entry point.
4361 //-----------------------------------------------------------------------------
4362 TQ3Status
Q3FileFormat_SetConfigurationData(TQ3RendererObject format,unsigned char * dataBuffer,TQ3Uns32 bufferSize)4363 Q3FileFormat_SetConfigurationData(TQ3RendererObject format, unsigned char *dataBuffer, TQ3Uns32 bufferSize)
4364 {
4365
4366
4367 // Release build checks
4368 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4369 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(dataBuffer), kQ3Failure);
4370
4371
4372
4373 // Debug build checks
4374 #if Q3_DEBUG
4375 if (0) // Further checks on renderer
4376 return(kQ3Failure);
4377
4378 if (0) // Further checks on dataBuffer
4379 return(kQ3Failure);
4380
4381 if (0) // Further checks on bufferSize
4382 return(kQ3Failure);
4383 #endif
4384
4385
4386
4387 // Call the bottleneck
4388 E3System_Bottleneck();
4389
4390
4391
4392 // Call our implementation
4393 return(E3FileFormat_SetConfigurationData(format, dataBuffer, bufferSize));
4394 }
4395
4396
4397
4398
4399
4400 //=============================================================================
4401 // Q3FileFormat_GenericReadBinary_8 : Quesa API entry point.
4402 //-----------------------------------------------------------------------------
4403 TQ3Status
Q3FileFormat_GenericReadBinary_8(TQ3FileFormatObject format,TQ3Int8 * data)4404 Q3FileFormat_GenericReadBinary_8(TQ3FileFormatObject format, TQ3Int8 *data)
4405 {
4406
4407
4408 // Release build checks
4409 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4410 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4411
4412
4413
4414 // Debug build checks
4415 #if Q3_DEBUG
4416 if (0) // Further checks on format
4417 return(kQ3Failure);
4418
4419 if (0) // Further checks on data
4420 return(kQ3Failure);
4421 #endif
4422
4423
4424
4425 // Call the bottleneck
4426 E3System_Bottleneck();
4427
4428
4429
4430 // Call our implementation
4431 return(E3FileFormat_GenericReadBinary_8(format, data));
4432 }
4433
4434
4435
4436
4437
4438 //=============================================================================
4439 // Q3FileFormat_GenericReadBinary_16 : Quesa API entry point.
4440 //-----------------------------------------------------------------------------
4441 TQ3Status
Q3FileFormat_GenericReadBinary_16(TQ3FileFormatObject format,TQ3Int16 * data)4442 Q3FileFormat_GenericReadBinary_16(TQ3FileFormatObject format, TQ3Int16 *data)
4443 {
4444
4445
4446 // Release build checks
4447 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4448 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4449
4450
4451
4452 // Debug build checks
4453 #if Q3_DEBUG
4454 if (0) // Further checks on format
4455 return(kQ3Failure);
4456
4457 if (0) // Further checks on data
4458 return(kQ3Failure);
4459 #endif
4460
4461
4462
4463 // Call the bottleneck
4464 E3System_Bottleneck();
4465
4466
4467
4468 // Call our implementation
4469 return(E3FileFormat_GenericReadBinary_16(format, data));
4470 }
4471
4472
4473
4474
4475
4476 //=============================================================================
4477 // Q3FileFormat_GenericReadBinary_32 : Quesa API entry point.
4478 //-----------------------------------------------------------------------------
4479 TQ3Status
Q3FileFormat_GenericReadBinary_32(TQ3FileFormatObject format,TQ3Int32 * data)4480 Q3FileFormat_GenericReadBinary_32(TQ3FileFormatObject format, TQ3Int32 *data)
4481 {
4482
4483
4484 // Release build checks
4485 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4486 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4487
4488
4489
4490 // Debug build checks
4491 #if Q3_DEBUG
4492 if (0) // Further checks on format
4493 return(kQ3Failure);
4494
4495 if (0) // Further checks on data
4496 return(kQ3Failure);
4497 #endif
4498
4499
4500
4501 // Call the bottleneck
4502 E3System_Bottleneck();
4503
4504
4505
4506 // Call our implementation
4507 return(E3FileFormat_GenericReadBinary_32(format, data));
4508 }
4509
4510
4511
4512
4513
4514 //=============================================================================
4515 // Q3FileFormat_GenericReadBinary_64 : Quesa API entry point.
4516 //-----------------------------------------------------------------------------
4517 TQ3Status
Q3FileFormat_GenericReadBinary_64(TQ3FileFormatObject format,TQ3Int64 * data)4518 Q3FileFormat_GenericReadBinary_64(TQ3FileFormatObject format, TQ3Int64 *data)
4519 {
4520
4521
4522 // Release build checks
4523 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4524 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4525
4526
4527
4528 // Debug build checks
4529 #if Q3_DEBUG
4530 if (0) // Further checks on format
4531 return(kQ3Failure);
4532
4533 if (0) // Further checks on data
4534 return(kQ3Failure);
4535 #endif
4536
4537
4538
4539 // Call the bottleneck
4540 E3System_Bottleneck();
4541
4542
4543
4544 // Call our implementation
4545 return(E3FileFormat_GenericReadBinary_64(format, data));
4546 }
4547
4548
4549
4550
4551
4552 //=============================================================================
4553 // Q3FileFormat_GenericReadBinary_String : Quesa API entry point.
4554 //-----------------------------------------------------------------------------
4555 TQ3Status
Q3FileFormat_GenericReadBinary_String(TQ3FileFormatObject format,char * data,TQ3Uns32 * length)4556 Q3FileFormat_GenericReadBinary_String(TQ3FileFormatObject format, char *data, TQ3Uns32 *length)
4557 {
4558
4559
4560 // Release build checks
4561 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4562 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4563 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(length), kQ3Failure);
4564
4565
4566
4567 // Debug build checks
4568 #if Q3_DEBUG
4569 if (0) // Further checks on format
4570 return(kQ3Failure);
4571
4572 if (0) // Further checks on data
4573 return(kQ3Failure);
4574
4575 if (0) // Further checks on length
4576 return(kQ3Failure);
4577 #endif
4578
4579
4580
4581 // Call the bottleneck
4582 E3System_Bottleneck();
4583
4584
4585
4586 // Call our implementation
4587 return(E3FileFormat_GenericReadBinary_String(format, data, length));
4588 }
4589
4590
4591
4592
4593
4594 //=============================================================================
4595 // Q3FileFormat_GenericReadBinary_Raw : Quesa API entry point.
4596 //-----------------------------------------------------------------------------
4597 TQ3Status
Q3FileFormat_GenericReadBinary_Raw(TQ3FileFormatObject format,unsigned char * data,TQ3Uns32 length)4598 Q3FileFormat_GenericReadBinary_Raw(TQ3FileFormatObject format, unsigned char *data, TQ3Uns32 length)
4599 {
4600
4601
4602 // Release build checks
4603 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4604 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4605 Q3_REQUIRE_OR_RESULT(length != 0, kQ3Failure);
4606
4607
4608
4609 // Debug build checks
4610 #if Q3_DEBUG
4611 if (0) // Further checks on format
4612 return(kQ3Failure);
4613
4614 if (0) // Further checks on data
4615 return(kQ3Failure);
4616
4617 if (0) // Further checks on length
4618 return(kQ3Failure);
4619 #endif
4620
4621
4622
4623 // Call the bottleneck
4624 E3System_Bottleneck();
4625
4626
4627
4628 // Call our implementation
4629 return(E3FileFormat_GenericReadBinary_Raw(format, data, length));
4630 }
4631
4632
4633
4634
4635
4636 //=============================================================================
4637 // Q3FileFormat_GenericReadBinSwap_16 : Quesa API entry point.
4638 //-----------------------------------------------------------------------------
4639 TQ3Status
Q3FileFormat_GenericReadBinSwap_16(TQ3FileFormatObject format,TQ3Int16 * data)4640 Q3FileFormat_GenericReadBinSwap_16(TQ3FileFormatObject format, TQ3Int16 *data)
4641 {
4642
4643
4644 // Release build checks
4645 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4646 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4647
4648
4649
4650 // Debug build checks
4651 #if Q3_DEBUG
4652 if (0) // Further checks on format
4653 return(kQ3Failure);
4654
4655 if (0) // Further checks on data
4656 return(kQ3Failure);
4657 #endif
4658
4659
4660
4661 // Call the bottleneck
4662 E3System_Bottleneck();
4663
4664
4665
4666 // Call our implementation
4667 return(E3FileFormat_GenericReadBinSwap_16(format, data));
4668 }
4669
4670
4671
4672
4673
4674 //=============================================================================
4675 // Q3FileFormat_GenericReadBinSwap_32 : Quesa API entry point.
4676 //-----------------------------------------------------------------------------
4677 TQ3Status
Q3FileFormat_GenericReadBinSwap_32(TQ3FileFormatObject format,TQ3Int32 * data)4678 Q3FileFormat_GenericReadBinSwap_32(TQ3FileFormatObject format, TQ3Int32 *data)
4679 {
4680
4681
4682 // Release build checks
4683 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4684 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4685
4686
4687
4688 // Debug build checks
4689 #if Q3_DEBUG
4690 if (0) // Further checks on format
4691 return(kQ3Failure);
4692
4693 if (0) // Further checks on data
4694 return(kQ3Failure);
4695 #endif
4696
4697
4698
4699 // Call the bottleneck
4700 E3System_Bottleneck();
4701
4702
4703
4704 // Call our implementation
4705 return(E3FileFormat_GenericReadBinSwap_32(format, data));
4706 }
4707
4708
4709
4710
4711
4712 //=============================================================================
4713 // Q3FileFormat_GenericReadBinSwap_64 : Quesa API entry point.
4714 //-----------------------------------------------------------------------------
4715 TQ3Status
Q3FileFormat_GenericReadBinSwap_64(TQ3FileFormatObject format,TQ3Int64 * data)4716 Q3FileFormat_GenericReadBinSwap_64(TQ3FileFormatObject format, TQ3Int64 *data)
4717 {
4718
4719
4720 // Release build checks
4721 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4722 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
4723
4724
4725
4726 // Debug build checks
4727 #if Q3_DEBUG
4728 if (0) // Further checks on format
4729 return(kQ3Failure);
4730
4731 if (0) // Further checks on data
4732 return(kQ3Failure);
4733 #endif
4734
4735
4736
4737 // Call the bottleneck
4738 E3System_Bottleneck();
4739
4740
4741
4742 // Call our implementation
4743 return(E3FileFormat_GenericReadBinSwap_64(format, data));
4744 }
4745
4746
4747
4748
4749
4750 //=============================================================================
4751 // Q3FileFormat_GenericReadText_SkipBlanks : Quesa API entry point.
4752 //-----------------------------------------------------------------------------
4753 TQ3Status
Q3FileFormat_GenericReadText_SkipBlanks(TQ3FileFormatObject format)4754 Q3FileFormat_GenericReadText_SkipBlanks(TQ3FileFormatObject format)
4755 {
4756
4757
4758 // Release build checks
4759 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4760
4761
4762
4763 // Debug build checks
4764 #if Q3_DEBUG
4765 if (0) // Further checks on format
4766 return(kQ3Failure);
4767 #endif
4768
4769
4770
4771 // Call the bottleneck
4772 E3System_Bottleneck();
4773
4774
4775
4776 // Call our implementation
4777 return(E3FileFormat_GenericReadText_SkipBlanks(format));
4778 }
4779
4780
4781
4782
4783
4784 //=============================================================================
4785 // Q3FileFormat_GenericReadText_ReadUntilChars : Quesa API entry point.
4786 //-----------------------------------------------------------------------------
4787 TQ3Status
Q3FileFormat_GenericReadText_ReadUntilChars(TQ3FileFormatObject format,char * buffer,char * chars,TQ3Uns32 numChars,TQ3Boolean blanks,TQ3Int32 * foundChar,TQ3Uns32 maxLen,TQ3Uns32 * charsRead)4788 Q3FileFormat_GenericReadText_ReadUntilChars(TQ3FileFormatObject format,
4789 char *buffer,
4790 char *chars,
4791 TQ3Uns32 numChars,
4792 TQ3Boolean blanks,
4793 TQ3Int32 *foundChar,
4794 TQ3Uns32 maxLen,
4795 TQ3Uns32 *charsRead)
4796 {
4797
4798
4799 // Release build checks
4800 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4801 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(buffer), kQ3Failure);
4802 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(chars), kQ3Failure);
4803 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(foundChar), kQ3Failure);
4804 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(charsRead), kQ3Failure);
4805
4806
4807
4808 // Debug build checks
4809 #if Q3_DEBUG
4810 if (0) // Further checks on format
4811 return(kQ3Failure);
4812
4813 if (0) // Further checks on buffer
4814 return(kQ3Failure);
4815
4816 if (0) // Further checks on chars
4817 return(kQ3Failure);
4818
4819 if (0) // Further checks on numChars
4820 return(kQ3Failure);
4821
4822 if (0) // Further checks on blanks
4823 return(kQ3Failure);
4824
4825 if (0) // Further checks on foundChar
4826 return(kQ3Failure);
4827
4828 if (0) // Further checks on maxLen
4829 return(kQ3Failure);
4830
4831 if (0) // Further checks on charsRead
4832 return(kQ3Failure);
4833 #endif
4834
4835
4836
4837 // Call the bottleneck
4838 E3System_Bottleneck();
4839
4840
4841
4842 // Call our implementation
4843 return(E3FileFormat_GenericReadText_ReadUntilChars(format, buffer, chars, numChars, blanks, foundChar, maxLen, charsRead));
4844 }
4845
4846
4847
4848 //=============================================================================
4849 // Q3FileFormat_GenericWriteBinary_8 : Quesa API entry point.
4850 //-----------------------------------------------------------------------------
4851 TQ3Status
Q3FileFormat_GenericWriteBinary_8(TQ3FileFormatObject format,const TQ3Int8 * data)4852 Q3FileFormat_GenericWriteBinary_8(TQ3FileFormatObject format, const TQ3Int8* data)
4853 {
4854
4855
4856 // Release build checks
4857 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4858
4859
4860
4861 // Debug build checks
4862 #if Q3_DEBUG
4863 if (0) // Further checks on format
4864 return(kQ3Failure);
4865
4866 if (0) // Further checks on data
4867 return(kQ3Failure);
4868 #endif
4869
4870
4871
4872 // Call the bottleneck
4873 E3System_Bottleneck();
4874
4875
4876
4877 // Call our implementation
4878 return(E3FileFormat_GenericWriteBinary_8(format, data));
4879 }
4880
4881
4882
4883
4884
4885 //=============================================================================
4886 // Q3FileFormat_GenericWriteBinary_16 : Quesa API entry point.
4887 //-----------------------------------------------------------------------------
4888 TQ3Status
Q3FileFormat_GenericWriteBinary_16(TQ3FileFormatObject format,const TQ3Int16 * data)4889 Q3FileFormat_GenericWriteBinary_16(TQ3FileFormatObject format, const TQ3Int16* data)
4890 {
4891
4892
4893 // Release build checks
4894 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4895
4896
4897
4898 // Debug build checks
4899 #if Q3_DEBUG
4900 if (0) // Further checks on format
4901 return(kQ3Failure);
4902
4903 if (0) // Further checks on data
4904 return(kQ3Failure);
4905 #endif
4906
4907
4908
4909 // Call the bottleneck
4910 E3System_Bottleneck();
4911
4912
4913
4914 // Call our implementation
4915 return(E3FileFormat_GenericWriteBinary_16(format, data));
4916 }
4917
4918
4919
4920
4921
4922 //=============================================================================
4923 // Q3FileFormat_GenericWriteBinary_32 : Quesa API entry point.
4924 //-----------------------------------------------------------------------------
4925 TQ3Status
Q3FileFormat_GenericWriteBinary_32(TQ3FileFormatObject format,const TQ3Int32 * data)4926 Q3FileFormat_GenericWriteBinary_32(TQ3FileFormatObject format, const TQ3Int32* data)
4927 {
4928
4929
4930 // Release build checks
4931 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4932
4933
4934
4935 // Debug build checks
4936 #if Q3_DEBUG
4937 if (0) // Further checks on format
4938 return(kQ3Failure);
4939
4940 if (0) // Further checks on data
4941 return(kQ3Failure);
4942 #endif
4943
4944
4945
4946 // Call the bottleneck
4947 E3System_Bottleneck();
4948
4949
4950
4951 // Call our implementation
4952 return(E3FileFormat_GenericWriteBinary_32(format, data));
4953 }
4954
4955
4956
4957
4958
4959 //=============================================================================
4960 // Q3FileFormat_GenericWriteBinary_64 : Quesa API entry point.
4961 //-----------------------------------------------------------------------------
4962 TQ3Status
Q3FileFormat_GenericWriteBinary_64(TQ3FileFormatObject format,const TQ3Int64 * data)4963 Q3FileFormat_GenericWriteBinary_64(TQ3FileFormatObject format, const TQ3Int64* data)
4964 {
4965
4966
4967 // Release build checks
4968 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
4969
4970
4971
4972 // Debug build checks
4973 #if Q3_DEBUG
4974 if (0) // Further checks on format
4975 return(kQ3Failure);
4976
4977 if (0) // Further checks on data
4978 return(kQ3Failure);
4979 #endif
4980
4981
4982
4983 // Call the bottleneck
4984 E3System_Bottleneck();
4985
4986
4987
4988 // Call our implementation
4989 return(E3FileFormat_GenericWriteBinary_64(format, data));
4990 }
4991
4992
4993
4994
4995
4996 //=============================================================================
4997 // Q3FileFormat_GenericWriteBinary_String : Quesa API entry point.
4998 //-----------------------------------------------------------------------------
4999 TQ3Status
Q3FileFormat_GenericWriteBinary_String(TQ3FileFormatObject format,const char * data,TQ3Uns32 * length)5000 Q3FileFormat_GenericWriteBinary_String(TQ3FileFormatObject format, const char *data, TQ3Uns32 *length)
5001 {
5002
5003
5004 // Release build checks
5005 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
5006 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
5007 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(length), kQ3Failure);
5008
5009
5010
5011 // Debug build checks
5012 #if Q3_DEBUG
5013 if (0) // Further checks on format
5014 return(kQ3Failure);
5015
5016 if (0) // Further checks on data
5017 return(kQ3Failure);
5018
5019 if (0) // Further checks on length
5020 return(kQ3Failure);
5021 #endif
5022
5023
5024
5025 // Call the bottleneck
5026 E3System_Bottleneck();
5027
5028
5029
5030 // Call our implementation
5031 return(E3FileFormat_GenericWriteBinary_String(format, data, length));
5032 }
5033
5034
5035
5036
5037
5038 //=============================================================================
5039 // Q3FileFormat_GenericWriteBinary_Raw : Quesa API entry point.
5040 //-----------------------------------------------------------------------------
5041 TQ3Status
Q3FileFormat_GenericWriteBinary_Raw(TQ3FileFormatObject format,const unsigned char * data,TQ3Uns32 length)5042 Q3FileFormat_GenericWriteBinary_Raw(TQ3FileFormatObject format, const unsigned char *data, TQ3Uns32 length)
5043 {
5044
5045
5046 // Release build checks
5047 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
5048 Q3_REQUIRE_OR_RESULT(Q3_VALID_PTR(data), kQ3Failure);
5049 Q3_REQUIRE_OR_RESULT(length != 0, kQ3Failure);
5050
5051
5052
5053 // Debug build checks
5054 #if Q3_DEBUG
5055 if (0) // Further checks on format
5056 return(kQ3Failure);
5057
5058 if (0) // Further checks on data
5059 return(kQ3Failure);
5060
5061 if (0) // Further checks on length
5062 return(kQ3Failure);
5063 #endif
5064
5065
5066
5067 // Call the bottleneck
5068 E3System_Bottleneck();
5069
5070
5071
5072 // Call our implementation
5073 return(E3FileFormat_GenericWriteBinary_Raw(format, data, length));
5074 }
5075
5076
5077
5078
5079
5080 //=============================================================================
5081 // Q3FileFormat_GenericWriteBinSwap_16 : Quesa API entry point.
5082 //-----------------------------------------------------------------------------
5083 TQ3Status
Q3FileFormat_GenericWriteBinSwap_16(TQ3FileFormatObject format,const TQ3Int16 * data)5084 Q3FileFormat_GenericWriteBinSwap_16(TQ3FileFormatObject format, const TQ3Int16* data)
5085 {
5086
5087
5088 // Release build checks
5089 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
5090
5091
5092
5093 // Debug build checks
5094 #if Q3_DEBUG
5095 if (0) // Further checks on format
5096 return(kQ3Failure);
5097
5098 if (0) // Further checks on data
5099 return(kQ3Failure);
5100 #endif
5101
5102
5103
5104 // Call the bottleneck
5105 E3System_Bottleneck();
5106
5107
5108
5109 // Call our implementation
5110 return(E3FileFormat_GenericWriteBinSwap_16(format, data));
5111 }
5112
5113
5114
5115
5116
5117 //=============================================================================
5118 // Q3FileFormat_GenericWriteBinSwap_32 : Quesa API entry point.
5119 //-----------------------------------------------------------------------------
5120 TQ3Status
Q3FileFormat_GenericWriteBinSwap_32(TQ3FileFormatObject format,const TQ3Int32 * data)5121 Q3FileFormat_GenericWriteBinSwap_32(TQ3FileFormatObject format, const TQ3Int32* data)
5122 {
5123
5124
5125 // Release build checks
5126 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
5127
5128
5129
5130 // Debug build checks
5131 #if Q3_DEBUG
5132 if (0) // Further checks on format
5133 return(kQ3Failure);
5134
5135 if (0) // Further checks on data
5136 return(kQ3Failure);
5137 #endif
5138
5139
5140
5141 // Call the bottleneck
5142 E3System_Bottleneck();
5143
5144
5145
5146 // Call our implementation
5147 return(E3FileFormat_GenericWriteBinSwap_32(format, data));
5148 }
5149
5150
5151
5152
5153
5154 //=============================================================================
5155 // Q3FileFormat_GenericWriteBinSwap_64 : Quesa API entry point.
5156 //-----------------------------------------------------------------------------
5157 TQ3Status
Q3FileFormat_GenericWriteBinSwap_64(TQ3FileFormatObject format,const TQ3Int64 * data)5158 Q3FileFormat_GenericWriteBinSwap_64(TQ3FileFormatObject format, const TQ3Int64* data)
5159 {
5160
5161
5162 // Release build checks
5163 Q3_REQUIRE_OR_RESULT(Q3Object_IsType(format, (kQ3ObjectTypeFileFormat)), kQ3Failure);
5164
5165
5166
5167 // Debug build checks
5168 #if Q3_DEBUG
5169 if (0) // Further checks on format
5170 return(kQ3Failure);
5171
5172 if (0) // Further checks on data
5173 return(kQ3Failure);
5174 #endif
5175
5176
5177
5178 // Call the bottleneck
5179 E3System_Bottleneck();
5180
5181
5182
5183 // Call our implementation
5184 return(E3FileFormat_GenericWriteBinSwap_64(format, data));
5185 }
5186
5187
5188
5189
5190