-
Notifications
You must be signed in to change notification settings - Fork 2
/
3d_3do_logo.c
1295 lines (1094 loc) · 31.3 KB
/
3d_3do_logo.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* @author Erick Marquez - https://www.youtube.com/@retroloveletter
* Modifications by trapexit <[email protected]>
*
* @brief Simple 3D demo. This program will generate three 3D models
* which make up a 3DO logo.
*
* Each logo model can rotate. This program copies prestine vertices
* into quad local vertices before vertex manipulation based on stored
* angles. This prevents vertices from becoming distorted due to
* rounding errors after rotations by applying a reset. Obviously,
* based on project needs and optimizations, this can be handled in
* other ways.
*
* Backface culling support has been added. This code uses the first
* vertex on each quad during this calculation to obtain a point on
* the plane. For improved results when dealing with complex shapes
* and angles, you can grab the center of each quad instead.
*
* There are various optimizations that can be made. The goal was to
* keep this "simple" for demo purposes.
*
* The "camera" in this program is fixed, looking down into the
* positive Z direction. If a camera is added then updates to the
* world transform need to be made. You can keep track of a global
* view matrix in this case.
*
* Lighting for non-wireframe rendering is rudimentary and currently
* only works if backface culling is not disabled as it uses a dot
* product calculated there.
*
* The word 'object' in this code is synonymous with 3D model.
*
* This has been tested on hardware and runs a bit slower there
* compared to RetroArch->Opera.
*
* @date 2024-05-30
*/
#include "celutils.h"
#include "displayutils.h"
#include "mem.h"
#include "operamath.h"
#include "stdio.h"
#include "string.h"
/* ********************************************************************************************* */
/* ------------------------------------- CONSTANTS / MACROS ------------------------------------ */
/* ********************************************************************************************* */
#define SIZEOF_ARRAY(X) (sizeof(X)/sizeof((X)[0]))
// settings
#define DEBUG_MODE 0
#define CULL_BACKFACES 1
#define POLY_SIZE 4
#define SOLID_OBJ_COUNT 3
#define WIRE_OBJ_COUNT 3
#define HALF_SCREEN_W_F16 Convert32_F16(320/2)
#define HALF_SCREEN_H_F16 Convert32_F16(240/2)
#define MAX_OBJECT_VERTS 80
#define MAX_OBJECT_QUADS 20
#define VIEW_DIST_SHIFT 9
#define MAX_RENDERABLES 80
// added for context
#define FRACBITS_16 16
#define ONE_F16 Convert32_F16(1)
#define ANG_256_F16 Convert32_F16(256)
// flags
#define CULL_MASK 1
// cel helpers
#define LINK_CEL(a, b) (a->ccb_NextPtr = b)
#define CALC_WOFFSET_BPP8(width) ( (width % 4 == 0) ? (width / 4) : (width / 4 + 1) )
#define CLEAR_CEL_PREAMBLES(ccb) (ccb->ccb_PRE0 = ccb->ccb_PRE1 = 0)
#define SET_CEL_BPP8(ccb) (ccb->ccb_PRE0 |= (PRE0_BPP_8 << PRE0_BPP_SHIFT))
#define SET_CEL_WOFFSET10(ccb, width) (ccb->ccb_PRE1 |= ((width - PRE1_WOFFSET_PREFETCH) << PRE1_WOFFSET10_SHIFT))
#define SET_CEL_TLHPCNT(ccb, width) (ccb->ccb_PRE1 |= ((width - PRE1_TLHPCNT_PREFETCH) << PRE1_TLHPCNT_SHIFT))
#define SET_CEL_VCNT(ccb, height) (ccb->ccb_PRE0 |= ((height - PRE0_VCNT_PREFETCH) << PRE0_VCNT_SHIFT))
#define GET_CEL_BPP_VALUE(ccb) ((ccb->ccb_PRE0 & PRE0_BPP_MASK) >> PRE0_BPP_SHIFT)
#define PMV_0_MASK 0x1C00
#define PDV_0_MASK 0x300
#define PMV_0_SHIFT 10
#define PDV_0_SHIFT 8
/* ********************************************************************************************* */
/* ------------------------------------------- TYPES ------------------------------------------- */
/* ********************************************************************************************* */
typedef frac16 mat4x4[4][4];
typedef frac16 vector4[4];
typedef frac16 vector3[3];
typedef vector3 angle3;
typedef struct
{
frac16 x;
frac16 y;
frac16 z;
} vertex, vector, point;
// Polys that make up models
typedef struct
{
u32 vertIndex[POLY_SIZE];
vertex local[POLY_SIZE];
vertex world[POLY_SIZE];
Point screen[POLY_SIZE]; // Point is a 3DO lib type, handy for MapCel()
u32 flags;
CCB *ccb; // Used if not using wireframe mode
frac16 dp; // Holds dot product of quad normal to pov
} quad, *quadPtr;
// Models
typedef struct
{
u16 color;
u32 numVerts; // number of distinct vertices
u32 numQuads; // number of quads
point worldPos; // object center world position
vertex verts[MAX_OBJECT_VERTS];
quad quads[MAX_OBJECT_QUADS]; // quad/polygon vertex data
angle3 angles; // xyz rotation angles
} object, *objectPtr;
/* ************************************************************************* */
/* ---------------------------------- GLOBALS ------------------------------ */
/* ************************************************************************* */
static Item sport_ioreq;
static Item vbl_ioreq;
static ScreenContext *sc;
static objectPtr solid_objs[SOLID_OBJ_COUNT];
static objectPtr wire_objs_left[WIRE_OBJ_COUNT];
static objectPtr wire_objs_right[WIRE_OBJ_COUNT];
static const ubyte bppTable[] = {0, 1, 2, 4, 6, 8, 16, 0};
static CCB *renderables[MAX_RENDERABLES];
static u32 rend_count;
/* ------------------------------------------------------------------------- */
/* --------------------------- HARDCODED MODEL DATA ------------------------ */
/* ------------------------------------------------------------------------- */
// 16:16 fixed point format
// This data defines the 3DO logo in three parts
// Postfix naming convention is:
// _3 = (3)DO
// _d = 3(D)O
// _o = 3D(O)
// first model
const
static
vertex
verts_3[] =
{
{55609, 0, 31457},
{0, -55609, 31457},
{55609, 0, -31457},
{0, -55609, -31457},
{0, 55609, 31457},
{-55609, 0, 31457},
{0, 55609, -31457},
{-55609, 0, -31457}
};
static
const
u32
quads_3[] =
{
0, 4, 6, 2,
3, 2, 6, 7,
7, 6, 4, 5,
5, 1, 3, 7,
1, 0, 2, 3,
5, 4, 0, 1
};
// second model
static
const
vertex
verts_d[] =
{
{-52428, -46137, -31457},
{-52428, 46137, -31457},
{-52428, -46137, 31457},
{-52428, 46137, 31457},
{52428, -46137, -31457},
{52428, 46137, -31457},
{52428, -46137, 31457},
{52428, 46137, 31457}
};
static
const
u32
quads_d[] =
{
0, 1, 3, 2,
2, 3, 7, 6,
6, 7, 5, 4,
4, 5, 1, 0,
2, 6, 4, 0,
7, 3, 1, 5
};
// third model
static
const
vertex
verts_o[] =
{
{-7, 37538, 37559},
{-7, 2, 53107},
{-7, -37534, 37559},
{32499, 37538, 18791},
{45964, 2, 26565},
{32499, -37534, 18791},
{32499, 37538, -18744},
{45964, 2, -26518},
{32499, -37534, -18744},
{-8, 37538, -37512},
{-8, 2, -53060},
{-8, -37534, -37512},
{-686, -52905, 2034},
{-7, 53086, 23},
{-32515, 37538, -18744},
{-45980, 2, -26518},
{-32515, -37534, -18744},
{-32515, 37538, 18791},
{-45980, 2, 26565},
{-32515, -37534, 18791}
};
static
const
u32
quads_o[] =
{
2, 1, 4, 5,
1, 0, 3, 4,
13, 6, 3, 0,
4, 3, 6, 7,
5, 4, 7, 8,
2, 5, 12, 19,
7, 6, 9, 10,
8, 7, 10, 11,
11, 10, 15, 16,
5, 8, 11, 12,
10, 9, 14, 15,
16, 15, 18, 19,
16, 19, 12, 11,
13, 14, 9, 6,
15, 14, 17, 18,
19, 18, 1, 2,
18, 17, 0, 1,
13, 0, 17, 14
};
/* ************************************************************************* */
/* -------------------------------- PROTOTYPES ----------------------------- */
/* ************************************************************************* */
/**
* @brief Basic app setup
*/
static void init_demo(void);
/**
* @brief Create a 3D Object
* @param verts Pointer to linear vertex list
* @param numVerts Vertex count (xyz groups) in list, not linear list size
* @param quads Pointer to linear quad list
* @param numQuads Quad count (sets of 4) in list, not linear list size
* @param color Composite 3DO RGB color value
* @return objectPtr
*/
static objectPtr create_object(const vertex *verts,
const u32 numVerts,
const u32 *quads,
const u32 numQuads,
u16 color);
static objectPtr clone_obj(const objectPtr);
/**
* @brief Helper to set object position
* @param obj
* @param x
* @param y
* @param z
*/
static void set_object_pos(objectPtr obj, frac16 x, frac16 y, frac16 z);
/**
* @brief Updates 3D scene
*/
static void update_solid_objs(void);
static void update_wire_objs(void);
/**
* @brief Rebase prestine vertex data to model
*/
static void to_local(objectPtr obj);
/**
* @brief Transform model local space to world space
* @param obj
*/
static void local_to_world(objectPtr obj);
/**
* @brief Transform model world space to screen space
* @param obj
*/
static void world_to_screen(objectPtr obj);
/**
* @brief Draw model in wireframe
*
* @param obj
*/
static void render_wire_obj(objectPtr obj, const u16 color);
/**
* @brief Rotate model about any axis or combination of them
* @param obj
* @param xangle
* @param yangle
* @param zangle
*/
static void rotate_object(objectPtr obj, frac16 xangle, frac16 yangle, frac16 zangle);
/**
* @brief Simple matrix helper
* @param mat
*/
static void make_identity_mat4x4(mat4x4 mat);
/**
* @brief Simple matrix helper
* @param mat
*/
static void zero_mat4x4(mat4x4 mat);
/**
* @brief Simple matrix helper
* @param dest
* @param source
*/
static void copy_mat4x4(mat4x4 dest, mat4x4 source);
/**
* @brief Create a vector from two points in 3D space
* @param vector
* @param initial
* @param terminal
*/
static void point_to_vector(vector3 vector, vertex *initial, vertex *terminal);
/**
* @brief Test quad for backface removal. This check will set the quad's cull
* flag if it should be hidden, along with returning the check result for convenience.
*
* @param qptr
* @return TRUE if cull was set
*/
static boolean cull_backface(quadPtr qptr);
/**
* @brief Prep to render each quad as a linked cel
*/
static void prepare_renderables(void);
/**
* @brief Set pixc pmv value
* @param ccb
* @param pmv
*/
static void set_pixc_PMV(CCB *ccb, u32 pmv);
/**
* @brief Set pixc pdv value
* @param ccb
* @param pmv
*/
static void set_pixc_PDV(CCB *ccb, u32 pdv);
/**
* @brief Cel creation helper
* @param width
* @param height
* @param alloc TRUE to have function allocate source space for you
* @return CCB*
*/
static CCB *create_coded_cel8(u32 width, u32 height, boolean alloc);
/**
* @brief Cel creation helper
* @param width
* @param height
* @param color Composite 3DO RGB color value
* @return CCB*
*/
static CCB *create_coded_colored_cel8(u32 width, u32 height, u16 color);
/**
* @brief Cel data helper
* @param cel Cel to read source bytes from
* @return i32
*/
static size_t get_cel_source_bytes(CCB *cel);
/**
* @brief Cel data helper
* @param cel Cel to read row bytes from
* @return i32
*/
static size_t get_cel_row_bytes(CCB *cel);
/**
* @brief Cel data helper
* @param cel Cel to read bpp from
* @return i32
*/
static i32 get_cel_bpp(CCB *cel);
/**
* @brief Dumps object data for debugging
*
* @param obj
*/
static void dump_object(objectPtr obj);
/* ********************************************************************************************* */
/* ------------------------------------------- MAIN -------------------------------------------- */
/* ********************************************************************************************* */
#define RGB15_RED ((u16)MakeRGB15(31,0,0))
#define RGB15_BLUE ((u16)MakeRGB15(0,0,31))
#define RGB15_YELLOW ((u16)MakeRGB15(31,31,0))
#define RGB15_BLACK ((u16)MakeRGB15(0,0,0))
static
void
create_objects(void)
{
// "3" model
solid_objs[0] = create_object(verts_3,
SIZEOF_ARRAY(verts_3),
quads_3,
SIZEOF_ARRAY(quads_3)/4,
RGB15_RED);
set_object_pos(solid_objs[0],
Convert32_F16(0),
Convert32_F16(2),
Convert32_F16(18));
// "D" model
solid_objs[1] = create_object(verts_d,
SIZEOF_ARRAY(verts_d),
quads_d,
SIZEOF_ARRAY(quads_d)/4,
RGB15_BLUE);
set_object_pos(solid_objs[1],
Convert32_F16(0),
Convert32_F16(0),
Convert32_F16(18));
// "O" model
solid_objs[2] = create_object(verts_o,
SIZEOF_ARRAY(verts_o),
quads_o,
SIZEOF_ARRAY(quads_o)/4,
RGB15_YELLOW);
set_object_pos(solid_objs[2],
Convert32_F16(0),
Convert32_F16(-2),
Convert32_F16(18));
// "3" model
wire_objs_left[0] = clone_obj(solid_objs[0]);
set_object_pos(wire_objs_left[0],
Convert32_F16(3),
Convert32_F16(2),
Convert32_F16(18));
// "D" model
wire_objs_left[1] = clone_obj(solid_objs[1]);
set_object_pos(wire_objs_left[1],
Convert32_F16(3),
Convert32_F16(0),
Convert32_F16(18));
// "O" model
wire_objs_left[2] = clone_obj(solid_objs[2]);
set_object_pos(wire_objs_left[2],
Convert32_F16(3),
Convert32_F16(-2),
Convert32_F16(18));
// "3" model
wire_objs_right[0] = clone_obj(solid_objs[0]);
set_object_pos(wire_objs_right[0],
Convert32_F16(-3),
Convert32_F16(2),
Convert32_F16(18));
// "D" model
wire_objs_right[1] = clone_obj(solid_objs[1]);
set_object_pos(wire_objs_right[1],
Convert32_F16(-3),
Convert32_F16(0),
Convert32_F16(18));
// "O" model
wire_objs_right[2] = clone_obj(solid_objs[2]);
set_object_pos(wire_objs_right[2],
Convert32_F16(-3),
Convert32_F16(-2),
Convert32_F16(18));
}
static
void
render_wire_objs(objectPtr objs_[],
const u32 objs_count_)
{
u32 i;
for(i = 0; i < objs_count_; i++)
render_wire_obj(objs_[i],
objs_[i]->color);
}
static
void
clear_screen(void)
{
SetVRAMPages(sport_ioreq,
sc->sc_Bitmaps[sc->sc_CurrentScreen]->bm_Buffer,
0,
sc->sc_NumBitmapPages,
0xFFFFFFFF);
}
int
main_3d_3do_logo()
{
init_demo();
create_objects();
while(TRUE)
{
rend_count = 0;
clear_screen();
update_wire_objs();
render_wire_objs(wire_objs_left,WIRE_OBJ_COUNT);
render_wire_objs(wire_objs_right,WIRE_OBJ_COUNT);
// render using cels proper
update_solid_objs();
prepare_renderables();
if(rend_count > 0)
DrawCels(sc->sc_BitmapItems[sc->sc_CurrentScreen], renderables[0]);
{
int i;
for(i = 0; i < SIZEOF_ARRAY(solid_objs); i++)
render_wire_obj(solid_objs[i], RGB15_BLACK);
}
DisplayScreen(sc->sc_ScreenItems[sc->sc_CurrentScreen], NULL);
// flip current screen
sc->sc_CurrentScreen = 1 - sc->sc_CurrentScreen;
WaitVBL(vbl_ioreq, 1);
}
return(0);
}
/* ************************************************************************* */
/* --------------------- FUNCTION IMPLEMENTATION --------------------------- */
/* ************************************************************************* */
static
void
init_demo(void)
{
u32 display_type;
// folios
OpenGraphicsFolio();
OpenMathFolio();
// screen
sc = (ScreenContext*) AllocMem(sizeof(ScreenContext), MEMTYPE_ANY);
QueryGraphics(QUERYGRAF_TAG_DEFAULTDISPLAYTYPE, &display_type);
if((display_type == DI_TYPE_PAL1) || (display_type == DI_TYPE_PAL2))
display_type = DI_TYPE_PAL1;
else
display_type = DI_TYPE_NTSC;
CreateBasicDisplay(sc, display_type, 2);
sc->sc_CurrentScreen = 0;
// IO request Items
sport_ioreq = GetVRAMIOReq();
vbl_ioreq = GetVBLIOReq();
}
static
void
update_obj(objectPtr obj_,
frac16 x_rot_,
frac16 y_rot_,
frac16 z_rot_)
{
// copy prestine verts into local data
to_local(obj_);
// you can play with rotations here to create complex rotations
obj_->angles[0] += x_rot_; // x rot
obj_->angles[1] += y_rot_; // y rot
obj_->angles[2] += z_rot_; // z rot
// clamp angles
if(obj_->angles[0] >= ANG_256_F16)
obj_->angles[0] -= ANG_256_F16;
if(obj_->angles[1] >= ANG_256_F16)
obj_->angles[1] -= ANG_256_F16;
if(obj_->angles[2] >= ANG_256_F16)
obj_->angles[2] -= ANG_256_F16;
// rotate only after local transform above
rotate_object(obj_,
obj_->angles[0], // x rot
obj_->angles[1], // y rot
obj_->angles[2]); // z rot
local_to_world(obj_);
world_to_screen(obj_);
}
static
void
update_wire_objs(void)
{
u32 i;
for(i = 0; i < SIZEOF_ARRAY(wire_objs_left); i++)
update_obj(wire_objs_left[i],
Convert32_F16(0),
Convert32_F16(1),
Convert32_F16(0));
for(i = 0; i < SIZEOF_ARRAY(wire_objs_right); i++)
update_obj(wire_objs_right[i],
Convert32_F16(0),
Convert32_F16(-1),
Convert32_F16(0));
}
static
void
update_solid_objs(void)
{
u32 i;
for(i = 0; i < SIZEOF_ARRAY(solid_objs); i++)
update_obj(solid_objs[i],
Convert32_F16(0),
Convert32_F16(-1)>>3,
Convert32_F16(0));
}
static
void
prepare_renderables(void)
{
u32 i, j;
quadPtr qptr;
objectPtr optr;
for (i = 0; i < SIZEOF_ARRAY(solid_objs); i++)
{
optr = solid_objs[i];
for (j = 0; j < optr->numQuads; j++)
{
qptr = &optr->quads[j];
#if CULL_BACKFACES
if(qptr->flags & CULL_MASK)
continue;
#endif
if(rend_count >= MAX_RENDERABLES)
{
rend_count = MAX_RENDERABLES;
goto hard_stop;
}
// quick and dirty lighting just to see the shapes..
if(qptr->dp < 6)
{
set_pixc_PMV(qptr->ccb, 4);
set_pixc_PDV(qptr->ccb, 3);
}
else
{
set_pixc_PMV(qptr->ccb, 7);
set_pixc_PDV(qptr->ccb, 3);
}
MapCel(qptr->ccb, qptr->screen);
renderables[rend_count++] = qptr->ccb;
}
}
hard_stop:
// link cels
if(rend_count > 0)
{
for (i = 0; i < rend_count - 1; i++)
{
LINK_CEL(renderables[i], renderables[i+1]);
UNLAST_CEL(renderables[i]);
}
LAST_CEL(renderables[rend_count-1]);
}
}
static
void
to_local(objectPtr obj)
{
u32 i, j;
quadPtr qptr;
for (i = 0; i < obj->numQuads; i++)
{
qptr = &obj->quads[i];
for (j = 0; j < POLY_SIZE; j++)
{
qptr->local[j].x = obj->verts[qptr->vertIndex[j]].x;
qptr->local[j].y = obj->verts[qptr->vertIndex[j]].y;
qptr->local[j].z = obj->verts[qptr->vertIndex[j]].z;
}
}
}
static
void
local_to_world(objectPtr obj)
{
u32 i, j;
quadPtr qptr;
for (i = 0; i < obj->numQuads; i++)
{
qptr = &obj->quads[i];
// remove prior cull flag
#if CULL_BACKFACES
qptr->flags &= ~CULL_MASK;
#endif
for (j = 0; j < POLY_SIZE; j++)
{
qptr->world[j].x = obj->worldPos.x + qptr->local[j].x;
qptr->world[j].y = obj->worldPos.y + qptr->local[j].y;
qptr->world[j].z = obj->worldPos.z + qptr->local[j].z;
#if CULL_BACKFACES
if(cull_backface(qptr))
qptr->flags |= CULL_MASK;
#endif
}
}
}
static
void
world_to_screen(objectPtr obj)
{
u32 i, j, z;
quadPtr qptr;
for (i = 0; i < obj->numQuads; i++)
{
qptr = &obj->quads[i];
#if CULL_BACKFACES
if(qptr->flags & CULL_MASK)
continue;
#endif
for (j = 0; j < POLY_SIZE; j++)
{
z = (qptr->world[j].z == 0) ? 1 : qptr->world[j].z; // avoid divide by zero
qptr->screen[j].pt_X = (DivSF16(qptr->world[j].x << VIEW_DIST_SHIFT, z) + HALF_SCREEN_W_F16) >> FRACBITS_16;
qptr->screen[j].pt_Y = (DivSF16(-qptr->world[j].y << VIEW_DIST_SHIFT, z) + HALF_SCREEN_H_F16) >> FRACBITS_16;
}
}
}
static
void
render_wire_obj(objectPtr obj_,
const u16 color_)
{
static GrafCon gcon;
u32 i, j;
quadPtr qptr;
SetFGPen(&gcon, color_);
for (i = 0; i < obj_->numQuads; i++)
{
qptr = &obj_->quads[i];
#if CULL_BACKFACES
if(qptr->flags & CULL_MASK)
continue;
#endif
gcon.gc_PenX = qptr->screen[0].pt_X;
gcon.gc_PenY = qptr->screen[0].pt_Y;
for (j = 1; j < POLY_SIZE; j++)
DrawTo(sc->sc_BitmapItems[sc->sc_CurrentScreen],
&gcon,
qptr->screen[j].pt_X,
qptr->screen[j].pt_Y);
DrawTo(sc->sc_BitmapItems[sc->sc_CurrentScreen],
&gcon,
qptr->screen[0].pt_X,
qptr->screen[0].pt_Y);
}
}
static
objectPtr
clone_obj(const objectPtr obj_)
{
objectPtr obj;
obj = (objectPtr)AllocMem(sizeof(*obj),MEMTYPE_DRAM);
if(obj == NULL)
return NULL;
memcpy(obj,obj_,sizeof(object));
return obj;
}
static
objectPtr
create_object(const vertex *verts,
const u32 numVerts,
const u32 *quads,
const u32 numQuads,
u16 color)
{
u32 i;
u32 j;
objectPtr obj;
obj = (objectPtr) AllocMem(sizeof(object), MEMTYPE_DRAM);
obj->numVerts = numVerts;
obj->numQuads = numQuads;
obj->color = color;
obj->angles[0] = obj->angles[1] = obj->angles[2] = 0;
// copy verts into proper vertex format
for (i = 0; i < numVerts; i++)
{
obj->verts[i].x = verts[i].x;
obj->verts[i].y = verts[i].y;
obj->verts[i].z = verts[i].z;
}
// copy quad luts
for (i = 0, j = 0; i < numQuads; i++, j+=4)
{
obj->quads[i].vertIndex[0] = quads[j+0];
obj->quads[i].vertIndex[1] = quads[j+1];
obj->quads[i].vertIndex[2] = quads[j+2];
obj->quads[i].vertIndex[3] = quads[j+3];
obj->quads[i].flags = 0;
obj->quads[i].dp = 0;
obj->quads[i].ccb = create_coded_colored_cel8(16, 16, color);
}
return(obj);
}
void
set_object_pos(objectPtr obj,
frac16 x,
frac16 y,
frac16 z)
{
obj->worldPos.x = x;
obj->worldPos.y = y;
obj->worldPos.z = z;
}
/* --------------------------------------------------------------------------------------------- */
/* ----------------------------------------- CORE MATH ----------------------------------------- */
/* --------------------------------------------------------------------------------------------- */
// This uses many local vars which should be trimmed down for better
// performance
static
void
rotate_object(objectPtr obj,
frac16 xangle,
frac16 yangle,
frac16 zangle)
{
u32 i, j;
quadPtr qptr;
mat4x4 rot, xrot, yrot, zrot, temp;
frac16 cos, sin;
u32 flags = 0;
// figure out the rotations we are doing
if(xangle != 0)
{
cos = CosF16(xangle);
sin = SinF16(xangle);
make_identity_mat4x4(xrot);
xrot[1][1] = cos;
xrot[1][2] = sin;
xrot[2][1] = -sin;
xrot[2][2] = cos;
flags |= 1;
}
if(yangle != 0)
{
cos = CosF16(yangle);
sin = SinF16(yangle);
make_identity_mat4x4(yrot);
yrot[0][0] = cos;
yrot[0][2] = -sin;
yrot[2][0] = sin;
yrot[2][2] = cos;
flags |= 2;
}
if(zangle != 0)
{
cos = CosF16(zangle);
sin = SinF16(zangle);
make_identity_mat4x4(zrot);
zrot[0][0] = cos;
zrot[0][1] = sin;
zrot[1][0] = -sin;
zrot[1][1] = cos;
flags |= 4;
}
// set up the final rotation matrix (rot) based on the flags set
switch (flags)
{
case 0: // this should not happen
break;
case 1: // x rotation
copy_mat4x4(rot,xrot);
break;