diff options
Diffstat (limited to 'apps')
-rw-r--r-- | apps/plugins/sdl/progs/quake/common.c | 97 | ||||
-rw-r--r-- | apps/plugins/sdl/progs/quake/common.h | 29 | ||||
-rw-r--r-- | apps/plugins/sdl/progs/quake/model.c | 191 |
3 files changed, 198 insertions, 119 deletions
diff --git a/apps/plugins/sdl/progs/quake/common.c b/apps/plugins/sdl/progs/quake/common.c index 11be234834..5e842b09ae 100644 --- a/apps/plugins/sdl/progs/quake/common.c +++ b/apps/plugins/sdl/progs/quake/common.c | |||
@@ -446,58 +446,111 @@ float (*LittleFloat) (float l); | |||
446 | 446 | ||
447 | short ShortSwap (short l) | 447 | short ShortSwap (short l) |
448 | { | 448 | { |
449 | byte b1,b2; | 449 | byte b1,b2; |
450 | 450 | ||
451 | b1 = l&255; | 451 | b1 = l&255; |
452 | b2 = (l>>8)&255; | 452 | b2 = (l>>8)&255; |
453 | 453 | ||
454 | return (b1<<8) + b2; | 454 | return (b1<<8) + b2; |
455 | } | 455 | } |
456 | 456 | ||
457 | short ShortNoSwap (short l) | 457 | short ShortNoSwap (short l) |
458 | { | 458 | { |
459 | return l; | 459 | return l; |
460 | } | 460 | } |
461 | 461 | ||
462 | int LongSwap (int l) | 462 | int LongSwap (int l) |
463 | { | 463 | { |
464 | byte b1,b2,b3,b4; | 464 | byte b1,b2,b3,b4; |
465 | 465 | ||
466 | b1 = l&255; | 466 | b1 = l&255; |
467 | b2 = (l>>8)&255; | 467 | b2 = (l>>8)&255; |
468 | b3 = (l>>16)&255; | 468 | b3 = (l>>16)&255; |
469 | b4 = (l>>24)&255; | 469 | b4 = (l>>24)&255; |
470 | 470 | ||
471 | return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4; | 471 | return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4; |
472 | } | 472 | } |
473 | 473 | ||
474 | int LongNoSwap (int l) | 474 | int LongNoSwap (int l) |
475 | { | 475 | { |
476 | return l; | 476 | return l; |
477 | } | 477 | } |
478 | 478 | ||
479 | float FloatSwap (float f) | 479 | float FloatSwap (float f) |
480 | { | 480 | { |
481 | union | ||
482 | { | ||
483 | float f; | ||
484 | byte b[4]; | ||
485 | } dat1, dat2; | ||
486 | |||
487 | |||
488 | dat1.f = f; | ||
489 | dat2.b[0] = dat1.b[3]; | ||
490 | dat2.b[1] = dat1.b[2]; | ||
491 | dat2.b[2] = dat1.b[1]; | ||
492 | dat2.b[3] = dat1.b[0]; | ||
493 | return dat2.f; | ||
494 | } | ||
495 | |||
496 | float FloatNoSwap (float f) | ||
497 | { | ||
498 | return f; | ||
499 | } | ||
500 | |||
501 | // safe for unaligned accesses | ||
502 | short ReadLittleShort (char *l) | ||
503 | { | ||
504 | return *(l + 0) | (*(l + 1) << 8); | ||
505 | } | ||
506 | |||
507 | short ReadBigShort (char *l) | ||
508 | { | ||
509 | return *(l + 1) | (*(l + 0) << 8); | ||
510 | } | ||
511 | |||
512 | int ReadLittleLong (char *l) | ||
513 | { | ||
514 | return *(l + 0) | (*(l + 1) << 8) | (*(l + 2) << 16) | (*(l + 3) << 24); | ||
515 | } | ||
516 | |||
517 | int ReadBigLong (char *l) | ||
518 | { | ||
519 | return *(l + 3) | (*(l + 2) << 8) | (*(l + 1) << 16) | (*(l + 0) << 24); | ||
520 | } | ||
521 | |||
522 | // same | ||
523 | float ReadLittleFloat (char *f) | ||
524 | { | ||
481 | union | 525 | union |
482 | { | 526 | { |
483 | float f; | 527 | float f; |
484 | byte b[4]; | 528 | byte b[4]; |
485 | } dat1, dat2; | 529 | } dat2; |
486 | 530 | ||
487 | 531 | ||
488 | dat1.f = f; | 532 | dat2.b[0] = f[0]; |
489 | dat2.b[0] = dat1.b[3]; | 533 | dat2.b[1] = f[1]; |
490 | dat2.b[1] = dat1.b[2]; | 534 | dat2.b[2] = f[2]; |
491 | dat2.b[2] = dat1.b[1]; | 535 | dat2.b[3] = f[3]; |
492 | dat2.b[3] = dat1.b[0]; | ||
493 | return dat2.f; | 536 | return dat2.f; |
494 | } | 537 | } |
495 | 538 | ||
496 | float FloatNoSwap (float f) | 539 | float ReadBigFloat (char *f) |
497 | { | 540 | { |
498 | return f; | 541 | union |
542 | { | ||
543 | float f; | ||
544 | byte b[4]; | ||
545 | } dat2; | ||
546 | |||
547 | |||
548 | dat2.b[0] = f[0]; | ||
549 | dat2.b[1] = f[1]; | ||
550 | dat2.b[2] = f[2]; | ||
551 | dat2.b[3] = f[3]; | ||
552 | return dat2.f; | ||
499 | } | 553 | } |
500 | |||
501 | /* | 554 | /* |
502 | ============================================================================== | 555 | ============================================================================== |
503 | 556 | ||
@@ -1136,6 +1189,7 @@ void COM_Init (char *basedir) | |||
1136 | { | 1189 | { |
1137 | byte swaptest[2] = {1,0}; | 1190 | byte swaptest[2] = {1,0}; |
1138 | 1191 | ||
1192 | #if 1 | ||
1139 | // set the byte swapping variables in a portable manner | 1193 | // set the byte swapping variables in a portable manner |
1140 | #ifdef SDL | 1194 | #ifdef SDL |
1141 | // This is necessary because egcs 1.1.1 mis-compiles swaptest with -O2 | 1195 | // This is necessary because egcs 1.1.1 mis-compiles swaptest with -O2 |
@@ -1162,6 +1216,7 @@ void COM_Init (char *basedir) | |||
1162 | BigFloat = FloatNoSwap; | 1216 | BigFloat = FloatNoSwap; |
1163 | LittleFloat = FloatSwap; | 1217 | LittleFloat = FloatSwap; |
1164 | } | 1218 | } |
1219 | #endif | ||
1165 | 1220 | ||
1166 | Cvar_RegisterVariable (®istered); | 1221 | Cvar_RegisterVariable (®istered); |
1167 | Cvar_RegisterVariable (&cmdline); | 1222 | Cvar_RegisterVariable (&cmdline); |
diff --git a/apps/plugins/sdl/progs/quake/common.h b/apps/plugins/sdl/progs/quake/common.h index a1ac227aff..8c6ab3a2dc 100644 --- a/apps/plugins/sdl/progs/quake/common.h +++ b/apps/plugins/sdl/progs/quake/common.h | |||
@@ -88,12 +88,29 @@ void InsertLinkAfter (link_t *l, link_t *after); | |||
88 | 88 | ||
89 | extern qboolean bigendien; | 89 | extern qboolean bigendien; |
90 | 90 | ||
91 | extern short (*BigShort) (short l); | 91 | // not safe on unaligned data |
92 | extern short (*LittleShort) (short l); | 92 | extern short (*BigShort) (short l); |
93 | extern int (*BigLong) (int l); | 93 | extern short (*LittleShort) (short l); |
94 | extern int (*LittleLong) (int l); | 94 | extern int (*BigLong) (int l); |
95 | extern float (*BigFloat) (float l); | 95 | extern int (*LittleLong) (int l); |
96 | extern float (*LittleFloat) (float l); | 96 | extern float (*BigFloat) (float l); |
97 | extern float (*LittleFloat) (float l); | ||
98 | |||
99 | #define LittleShortUnaligned(x) ReadLittleShort(((char*)(&(x)))) | ||
100 | #define BigShortUnaligned(x) ReadBigShort(((char*)&(x))) | ||
101 | #define LittleLongUnaligned(x) ReadLittleLong(((char*)&(x))) | ||
102 | #define BigLongUnaligned(x) ReadBigLong(((char*)&(x))) | ||
103 | #define LittleFloatUnaligned(x) ReadLittleFloat(((char*)&(x))) | ||
104 | #define BigFloatUnaligned(x) ReadBigFloat(((char*)&(x)) | ||
105 | |||
106 | |||
107 | // for unaligned | ||
108 | short ReadBigShort (char *l); | ||
109 | short ReadLittleShort (char *l); | ||
110 | int ReadBigLong (char *l); | ||
111 | int ReadLittleLong (char *l); | ||
112 | float ReadBigFloat (char *l); | ||
113 | float ReadLittleFloat (char *l); | ||
97 | 114 | ||
98 | //============================================================================ | 115 | //============================================================================ |
99 | 116 | ||
diff --git a/apps/plugins/sdl/progs/quake/model.c b/apps/plugins/sdl/progs/quake/model.c index 57fdfec993..4c16c7f0f5 100644 --- a/apps/plugins/sdl/progs/quake/model.c +++ b/apps/plugins/sdl/progs/quake/model.c | |||
@@ -255,6 +255,7 @@ Loads a model into the cache | |||
255 | */ | 255 | */ |
256 | model_t *Mod_LoadModel (model_t *mod, qboolean crash) | 256 | model_t *Mod_LoadModel (model_t *mod, qboolean crash) |
257 | { | 257 | { |
258 | //printf("loadmodel 1"); | ||
258 | unsigned *buf; | 259 | unsigned *buf; |
259 | byte stackbuf[1024]; // avoid dirtying the cache heap | 260 | byte stackbuf[1024]; // avoid dirtying the cache heap |
260 | 261 | ||
@@ -279,6 +280,8 @@ model_t *Mod_LoadModel (model_t *mod, qboolean crash) | |||
279 | // | 280 | // |
280 | // load the file | 281 | // load the file |
281 | // | 282 | // |
283 | |||
284 | //printf("loadmodel 2"); | ||
282 | buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, sizeof(stackbuf)); | 285 | buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, sizeof(stackbuf)); |
283 | if (!buf) | 286 | if (!buf) |
284 | { | 287 | { |
@@ -294,6 +297,7 @@ model_t *Mod_LoadModel (model_t *mod, qboolean crash) | |||
294 | 297 | ||
295 | loadmodel = mod; | 298 | loadmodel = mod; |
296 | 299 | ||
300 | //printf("loadmodel 3"); | ||
297 | // | 301 | // |
298 | // fill it in | 302 | // fill it in |
299 | // | 303 | // |
@@ -301,7 +305,7 @@ model_t *Mod_LoadModel (model_t *mod, qboolean crash) | |||
301 | // call the apropriate loader | 305 | // call the apropriate loader |
302 | mod->needload = NL_PRESENT; | 306 | mod->needload = NL_PRESENT; |
303 | 307 | ||
304 | switch (LittleLong(*(unsigned *)buf)) | 308 | switch (LittleLongUnaligned(buf[0])) |
305 | { | 309 | { |
306 | case IDPOLYHEADER: | 310 | case IDPOLYHEADER: |
307 | Mod_LoadAliasModel (mod, buf); | 311 | Mod_LoadAliasModel (mod, buf); |
@@ -330,7 +334,10 @@ model_t *Mod_ForName (char *name, qboolean crash) | |||
330 | { | 334 | { |
331 | model_t *mod; | 335 | model_t *mod; |
332 | 336 | ||
337 | //printf("modfor1"); | ||
338 | |||
333 | mod = Mod_FindName (name); | 339 | mod = Mod_FindName (name); |
340 | //printf("modfor2"); | ||
334 | 341 | ||
335 | return Mod_LoadModel (mod, crash); | 342 | return Mod_LoadModel (mod, crash); |
336 | } | 343 | } |
@@ -368,21 +375,21 @@ void Mod_LoadTextures (lump_t *l) | |||
368 | } | 375 | } |
369 | m = (dmiptexlump_t *)(mod_base + l->fileofs); | 376 | m = (dmiptexlump_t *)(mod_base + l->fileofs); |
370 | 377 | ||
371 | m->nummiptex = LittleLong (m->nummiptex); | 378 | m->nummiptex = LittleLongUnaligned (m->nummiptex); |
372 | 379 | ||
373 | loadmodel->numtextures = m->nummiptex; | 380 | loadmodel->numtextures = m->nummiptex; |
374 | loadmodel->textures = Hunk_AllocName (m->nummiptex * sizeof(*loadmodel->textures) , loadname); | 381 | loadmodel->textures = Hunk_AllocName (m->nummiptex * sizeof(*loadmodel->textures) , loadname); |
375 | 382 | ||
376 | for (i=0 ; i<m->nummiptex ; i++) | 383 | for (i=0 ; i<m->nummiptex ; i++) |
377 | { | 384 | { |
378 | m->dataofs[i] = LittleLong(m->dataofs[i]); | 385 | m->dataofs[i] = LittleLongUnaligned(m->dataofs[i]); |
379 | if (m->dataofs[i] == -1) | 386 | if (m->dataofs[i] == -1) |
380 | continue; | 387 | continue; |
381 | mt = (miptex_t *)((byte *)m + m->dataofs[i]); | 388 | mt = (miptex_t *)((byte *)m + m->dataofs[i]); |
382 | mt->width = LittleLong (mt->width); | 389 | mt->width = LittleLongUnaligned (mt->width); |
383 | mt->height = LittleLong (mt->height); | 390 | mt->height = LittleLongUnaligned (mt->height); |
384 | for (j=0 ; j<MIPLEVELS ; j++) | 391 | for (j=0 ; j<MIPLEVELS ; j++) |
385 | mt->offsets[j] = LittleLong (mt->offsets[j]); | 392 | mt->offsets[j] = LittleLongUnaligned (mt->offsets[j]); |
386 | 393 | ||
387 | if ( (mt->width & 15) || (mt->height & 15) ) | 394 | if ( (mt->width & 15) || (mt->height & 15) ) |
388 | Sys_Error ("Texture %s is not 16 aligned", mt->name); | 395 | Sys_Error ("Texture %s is not 16 aligned", mt->name); |
@@ -569,9 +576,9 @@ void Mod_LoadVertexes (lump_t *l) | |||
569 | 576 | ||
570 | for ( i=0 ; i<count ; i++, in++, out++) | 577 | for ( i=0 ; i<count ; i++, in++, out++) |
571 | { | 578 | { |
572 | out->position[0] = LittleFloat (in->point[0]); | 579 | out->position[0] = LittleFloatUnaligned (in->point[0]); |
573 | out->position[1] = LittleFloat (in->point[1]); | 580 | out->position[1] = LittleFloatUnaligned (in->point[1]); |
574 | out->position[2] = LittleFloat (in->point[2]); | 581 | out->position[2] = LittleFloatUnaligned (in->point[2]); |
575 | } | 582 | } |
576 | } | 583 | } |
577 | 584 | ||
@@ -599,15 +606,15 @@ void Mod_LoadSubmodels (lump_t *l) | |||
599 | { | 606 | { |
600 | for (j=0 ; j<3 ; j++) | 607 | for (j=0 ; j<3 ; j++) |
601 | { // spread the mins / maxs by a pixel | 608 | { // spread the mins / maxs by a pixel |
602 | out->mins[j] = LittleFloat (in->mins[j]) - 1; | 609 | out->mins[j] = LittleFloatUnaligned (in->mins[j]) - 1; |
603 | out->maxs[j] = LittleFloat (in->maxs[j]) + 1; | 610 | out->maxs[j] = LittleFloatUnaligned (in->maxs[j]) + 1; |
604 | out->origin[j] = LittleFloat (in->origin[j]); | 611 | out->origin[j] = LittleFloatUnaligned (in->origin[j]); |
605 | } | 612 | } |
606 | for (j=0 ; j<MAX_MAP_HULLS ; j++) | 613 | for (j=0 ; j<MAX_MAP_HULLS ; j++) |
607 | out->headnode[j] = LittleLong (in->headnode[j]); | 614 | out->headnode[j] = LittleLongUnaligned (in->headnode[j]); |
608 | out->visleafs = LittleLong (in->visleafs); | 615 | out->visleafs = LittleLongUnaligned (in->visleafs); |
609 | out->firstface = LittleLong (in->firstface); | 616 | out->firstface = LittleLongUnaligned (in->firstface); |
610 | out->numfaces = LittleLong (in->numfaces); | 617 | out->numfaces = LittleLongUnaligned (in->numfaces); |
611 | } | 618 | } |
612 | } | 619 | } |
613 | 620 | ||
@@ -633,8 +640,8 @@ void Mod_LoadEdges (lump_t *l) | |||
633 | 640 | ||
634 | for ( i=0 ; i<count ; i++, in++, out++) | 641 | for ( i=0 ; i<count ; i++, in++, out++) |
635 | { | 642 | { |
636 | out->v[0] = (unsigned short)LittleShort(in->v[0]); | 643 | out->v[0] = (unsigned short)LittleShortUnaligned(in->v[0]); |
637 | out->v[1] = (unsigned short)LittleShort(in->v[1]); | 644 | out->v[1] = (unsigned short)LittleShortUnaligned(in->v[1]); |
638 | } | 645 | } |
639 | } | 646 | } |
640 | 647 | ||
@@ -663,7 +670,7 @@ void Mod_LoadTexinfo (lump_t *l) | |||
663 | for ( i=0 ; i<count ; i++, in++, out++) | 670 | for ( i=0 ; i<count ; i++, in++, out++) |
664 | { | 671 | { |
665 | for (j=0 ; j<8 ; j++) | 672 | for (j=0 ; j<8 ; j++) |
666 | out->vecs[0][j] = LittleFloat (in->vecs[0][j]); | 673 | out->vecs[0][j] = LittleFloatUnaligned (in->vecs[0][j]); |
667 | len1 = Length (out->vecs[0]); | 674 | len1 = Length (out->vecs[0]); |
668 | len2 = Length (out->vecs[1]); | 675 | len2 = Length (out->vecs[1]); |
669 | len1 = (len1 + len2)/2; | 676 | len1 = (len1 + len2)/2; |
@@ -682,8 +689,8 @@ void Mod_LoadTexinfo (lump_t *l) | |||
682 | out->mipadjust = 1 / floor( (len1+len2)/2 + 0.1 ); | 689 | out->mipadjust = 1 / floor( (len1+len2)/2 + 0.1 ); |
683 | #endif | 690 | #endif |
684 | 691 | ||
685 | miptex = LittleLong (in->miptex); | 692 | miptex = LittleLongUnaligned (in->miptex); |
686 | out->flags = LittleLong (in->flags); | 693 | out->flags = LittleLongUnaligned (in->flags); |
687 | 694 | ||
688 | if (!loadmodel->textures) | 695 | if (!loadmodel->textures) |
689 | { | 696 | { |
@@ -781,18 +788,18 @@ void Mod_LoadFaces (lump_t *l) | |||
781 | 788 | ||
782 | for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++) | 789 | for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++) |
783 | { | 790 | { |
784 | out->firstedge = LittleLong(in->firstedge); | 791 | out->firstedge = LittleLongUnaligned(in->firstedge); |
785 | out->numedges = LittleShort(in->numedges); | 792 | out->numedges = LittleShortUnaligned(in->numedges); |
786 | out->flags = 0; | 793 | out->flags = 0; |
787 | 794 | ||
788 | planenum = LittleShort(in->planenum); | 795 | planenum = LittleShortUnaligned(in->planenum); |
789 | side = LittleShort(in->side); | 796 | side = LittleShortUnaligned(in->side); |
790 | if (side) | 797 | if (side) |
791 | out->flags |= SURF_PLANEBACK; | 798 | out->flags |= SURF_PLANEBACK; |
792 | 799 | ||
793 | out->plane = loadmodel->planes + planenum; | 800 | out->plane = loadmodel->planes + planenum; |
794 | 801 | ||
795 | out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo); | 802 | out->texinfo = loadmodel->texinfo + LittleShortUnaligned (in->texinfo); |
796 | 803 | ||
797 | CalcSurfaceExtents (out); | 804 | CalcSurfaceExtents (out); |
798 | 805 | ||
@@ -800,7 +807,7 @@ void Mod_LoadFaces (lump_t *l) | |||
800 | 807 | ||
801 | for (i=0 ; i<MAXLIGHTMAPS ; i++) | 808 | for (i=0 ; i<MAXLIGHTMAPS ; i++) |
802 | out->styles[i] = in->styles[i]; | 809 | out->styles[i] = in->styles[i]; |
803 | i = LittleLong(in->lightofs); | 810 | i = LittleLongUnaligned(in->lightofs); |
804 | if (i == -1) | 811 | if (i == -1) |
805 | out->samples = NULL; | 812 | out->samples = NULL; |
806 | else | 813 | else |
@@ -866,19 +873,19 @@ void Mod_LoadNodes (lump_t *l) | |||
866 | { | 873 | { |
867 | for (j=0 ; j<3 ; j++) | 874 | for (j=0 ; j<3 ; j++) |
868 | { | 875 | { |
869 | out->minmaxs[j] = LittleShort (in->mins[j]); | 876 | out->minmaxs[j] = LittleShortUnaligned (in->mins[j]); |
870 | out->minmaxs[3+j] = LittleShort (in->maxs[j]); | 877 | out->minmaxs[3+j] = LittleShortUnaligned (in->maxs[j]); |
871 | } | 878 | } |
872 | 879 | ||
873 | p = LittleLong(in->planenum); | 880 | p = LittleLongUnaligned(in->planenum); |
874 | out->plane = loadmodel->planes + p; | 881 | out->plane = loadmodel->planes + p; |
875 | 882 | ||
876 | out->firstsurface = LittleShort (in->firstface); | 883 | out->firstsurface = LittleShortUnaligned (in->firstface); |
877 | out->numsurfaces = LittleShort (in->numfaces); | 884 | out->numsurfaces = LittleShortUnaligned (in->numfaces); |
878 | 885 | ||
879 | for (j=0 ; j<2 ; j++) | 886 | for (j=0 ; j<2 ; j++) |
880 | { | 887 | { |
881 | p = LittleShort (in->children[j]); | 888 | p = LittleShortUnaligned (in->children[j]); |
882 | if (p >= 0) | 889 | if (p >= 0) |
883 | out->children[j] = loadmodel->nodes + p; | 890 | out->children[j] = loadmodel->nodes + p; |
884 | else | 891 | else |
@@ -913,18 +920,18 @@ void Mod_LoadLeafs (lump_t *l) | |||
913 | { | 920 | { |
914 | for (j=0 ; j<3 ; j++) | 921 | for (j=0 ; j<3 ; j++) |
915 | { | 922 | { |
916 | out->minmaxs[j] = LittleShort (in->mins[j]); | 923 | out->minmaxs[j] = LittleShortUnaligned (in->mins[j]); |
917 | out->minmaxs[3+j] = LittleShort (in->maxs[j]); | 924 | out->minmaxs[3+j] = LittleShortUnaligned (in->maxs[j]); |
918 | } | 925 | } |
919 | 926 | ||
920 | p = LittleLong(in->contents); | 927 | p = LittleLongUnaligned(in->contents); |
921 | out->contents = p; | 928 | out->contents = p; |
922 | 929 | ||
923 | out->firstmarksurface = loadmodel->marksurfaces + | 930 | out->firstmarksurface = loadmodel->marksurfaces + |
924 | LittleShort(in->firstmarksurface); | 931 | LittleShortUnaligned(in->firstmarksurface); |
925 | out->nummarksurfaces = LittleShort(in->nummarksurfaces); | 932 | out->nummarksurfaces = LittleShortUnaligned(in->nummarksurfaces); |
926 | 933 | ||
927 | p = LittleLong(in->visofs); | 934 | p = LittleLongUnaligned(in->visofs); |
928 | if (p == -1) | 935 | if (p == -1) |
929 | out->compressed_vis = NULL; | 936 | out->compressed_vis = NULL; |
930 | else | 937 | else |
@@ -982,9 +989,9 @@ void Mod_LoadClipnodes (lump_t *l) | |||
982 | 989 | ||
983 | for (i=0 ; i<count ; i++, out++, in++) | 990 | for (i=0 ; i<count ; i++, out++, in++) |
984 | { | 991 | { |
985 | out->planenum = LittleLong(in->planenum); | 992 | out->planenum = LittleLongUnaligned(in->planenum); |
986 | out->children[0] = LittleShort(in->children[0]); | 993 | out->children[0] = LittleShortUnaligned(in->children[0]); |
987 | out->children[1] = LittleShort(in->children[1]); | 994 | out->children[1] = LittleShortUnaligned(in->children[1]); |
988 | } | 995 | } |
989 | } | 996 | } |
990 | 997 | ||
@@ -1049,7 +1056,7 @@ void Mod_LoadMarksurfaces (lump_t *l) | |||
1049 | 1056 | ||
1050 | for ( i=0 ; i<count ; i++) | 1057 | for ( i=0 ; i<count ; i++) |
1051 | { | 1058 | { |
1052 | j = LittleShort(in[i]); | 1059 | j = LittleShortUnaligned(in[i]); |
1053 | if (j >= loadmodel->numsurfaces) | 1060 | if (j >= loadmodel->numsurfaces) |
1054 | Sys_Error ("Mod_ParseMarksurfaces: bad surface number"); | 1061 | Sys_Error ("Mod_ParseMarksurfaces: bad surface number"); |
1055 | out[i] = loadmodel->surfaces + j; | 1062 | out[i] = loadmodel->surfaces + j; |
@@ -1076,7 +1083,7 @@ void Mod_LoadSurfedges (lump_t *l) | |||
1076 | loadmodel->numsurfedges = count; | 1083 | loadmodel->numsurfedges = count; |
1077 | 1084 | ||
1078 | for ( i=0 ; i<count ; i++) | 1085 | for ( i=0 ; i<count ; i++) |
1079 | out[i] = LittleLong (in[i]); | 1086 | out[i] = LittleLongUnaligned (in[i]); |
1080 | } | 1087 | } |
1081 | 1088 | ||
1082 | /* | 1089 | /* |
@@ -1106,13 +1113,13 @@ void Mod_LoadPlanes (lump_t *l) | |||
1106 | bits = 0; | 1113 | bits = 0; |
1107 | for (j=0 ; j<3 ; j++) | 1114 | for (j=0 ; j<3 ; j++) |
1108 | { | 1115 | { |
1109 | out->normal[j] = LittleFloat (in->normal[j]); | 1116 | out->normal[j] = LittleFloatUnaligned (in->normal[j]); |
1110 | if (out->normal[j] < 0) | 1117 | if (out->normal[j] < 0) |
1111 | bits |= 1<<j; | 1118 | bits |= 1<<j; |
1112 | } | 1119 | } |
1113 | 1120 | ||
1114 | out->dist = LittleFloat (in->dist); | 1121 | out->dist = LittleFloatUnaligned (in->dist); |
1115 | out->type = LittleLong (in->type); | 1122 | out->type = LittleLongUnaligned (in->type); |
1116 | out->signbits = bits; | 1123 | out->signbits = bits; |
1117 | } | 1124 | } |
1118 | } | 1125 | } |
@@ -1150,7 +1157,7 @@ void Mod_LoadBrushModel (model_t *mod, void *buffer) | |||
1150 | 1157 | ||
1151 | header = (dheader_t *)buffer; | 1158 | header = (dheader_t *)buffer; |
1152 | 1159 | ||
1153 | i = LittleLong (header->version); | 1160 | i = LittleLongUnaligned (header->version); |
1154 | if (i != BSPVERSION) | 1161 | if (i != BSPVERSION) |
1155 | rb->splashf (HZ, "Mod_LoadBrushModel: %s has wrong version number (%i should be %i)", mod->name, i, BSPVERSION); | 1162 | rb->splashf (HZ, "Mod_LoadBrushModel: %s has wrong version number (%i should be %i)", mod->name, i, BSPVERSION); |
1156 | 1163 | ||
@@ -1158,7 +1165,7 @@ void Mod_LoadBrushModel (model_t *mod, void *buffer) | |||
1158 | mod_base = (byte *)header; | 1165 | mod_base = (byte *)header; |
1159 | 1166 | ||
1160 | for (i=0 ; i<sizeof(dheader_t)/4 ; i++) | 1167 | for (i=0 ; i<sizeof(dheader_t)/4 ; i++) |
1161 | ((int *)header)[i] = LittleLong ( ((int *)header)[i]); | 1168 | ((int *)header)[i] = LittleLongUnaligned ( ((int *)header)[i]); |
1162 | 1169 | ||
1163 | // load into heap | 1170 | // load into heap |
1164 | 1171 | ||
@@ -1292,7 +1299,7 @@ void * Mod_LoadAliasGroup (void * pin, int *pframeindex, int numv, | |||
1292 | 1299 | ||
1293 | pingroup = (daliasgroup_t *)pin; | 1300 | pingroup = (daliasgroup_t *)pin; |
1294 | 1301 | ||
1295 | numframes = LittleLong (pingroup->numframes); | 1302 | numframes = LittleLongUnaligned (pingroup->numframes); |
1296 | 1303 | ||
1297 | paliasgroup = Hunk_AllocName (sizeof (maliasgroup_t) + | 1304 | paliasgroup = Hunk_AllocName (sizeof (maliasgroup_t) + |
1298 | (numframes - 1) * sizeof (paliasgroup->frames[0]), loadname); | 1305 | (numframes - 1) * sizeof (paliasgroup->frames[0]), loadname); |
@@ -1316,7 +1323,7 @@ void * Mod_LoadAliasGroup (void * pin, int *pframeindex, int numv, | |||
1316 | 1323 | ||
1317 | for (i=0 ; i<numframes ; i++) | 1324 | for (i=0 ; i<numframes ; i++) |
1318 | { | 1325 | { |
1319 | *poutintervals = LittleFloat (pin_intervals->interval); | 1326 | *poutintervals = LittleFloatUnaligned (pin_intervals->interval); |
1320 | if (*poutintervals <= 0.0) | 1327 | if (*poutintervals <= 0.0) |
1321 | Sys_Error ("Mod_LoadAliasGroup: interval<=0"); | 1328 | Sys_Error ("Mod_LoadAliasGroup: interval<=0"); |
1322 | 1329 | ||
@@ -1396,7 +1403,7 @@ void * Mod_LoadAliasSkinGroup (void * pin, int *pskinindex, int skinsize, | |||
1396 | 1403 | ||
1397 | pinskingroup = (daliasskingroup_t *)pin; | 1404 | pinskingroup = (daliasskingroup_t *)pin; |
1398 | 1405 | ||
1399 | numskins = LittleLong (pinskingroup->numskins); | 1406 | numskins = LittleLongUnaligned (pinskingroup->numskins); |
1400 | 1407 | ||
1401 | paliasskingroup = Hunk_AllocName (sizeof (maliasskingroup_t) + | 1408 | paliasskingroup = Hunk_AllocName (sizeof (maliasskingroup_t) + |
1402 | (numskins - 1) * sizeof (paliasskingroup->skindescs[0]), | 1409 | (numskins - 1) * sizeof (paliasskingroup->skindescs[0]), |
@@ -1414,7 +1421,7 @@ void * Mod_LoadAliasSkinGroup (void * pin, int *pskinindex, int skinsize, | |||
1414 | 1421 | ||
1415 | for (i=0 ; i<numskins ; i++) | 1422 | for (i=0 ; i<numskins ; i++) |
1416 | { | 1423 | { |
1417 | *poutskinintervals = LittleFloat (pinskinintervals->interval); | 1424 | *poutskinintervals = LittleFloatUnaligned (pinskinintervals->interval); |
1418 | if (*poutskinintervals <= 0) | 1425 | if (*poutskinintervals <= 0) |
1419 | Sys_Error ("Mod_LoadAliasSkinGroup: interval<=0"); | 1426 | Sys_Error ("Mod_LoadAliasSkinGroup: interval<=0"); |
1420 | 1427 | ||
@@ -1459,7 +1466,7 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1459 | 1466 | ||
1460 | pinmodel = (mdl_t *)buffer; | 1467 | pinmodel = (mdl_t *)buffer; |
1461 | 1468 | ||
1462 | version = LittleLong (pinmodel->version); | 1469 | version = LittleLongUnaligned (pinmodel->version); |
1463 | if (version != ALIAS_VERSION) | 1470 | if (version != ALIAS_VERSION) |
1464 | Sys_Error ("%s has wrong version number (%i should be %i)", | 1471 | Sys_Error ("%s has wrong version number (%i should be %i)", |
1465 | mod->name, version, ALIAS_VERSION); | 1472 | mod->name, version, ALIAS_VERSION); |
@@ -1468,33 +1475,33 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1468 | // allocate space for a working header, plus all the data except the frames, | 1475 | // allocate space for a working header, plus all the data except the frames, |
1469 | // skin and group info | 1476 | // skin and group info |
1470 | // | 1477 | // |
1471 | size = sizeof (aliashdr_t) + (LittleLong (pinmodel->numframes) - 1) * | 1478 | size = sizeof (aliashdr_t) + (LittleLongUnaligned (pinmodel->numframes) - 1) * |
1472 | sizeof (pheader->frames[0]) + | 1479 | sizeof (pheader->frames[0]) + |
1473 | sizeof (mdl_t) + | 1480 | sizeof (mdl_t) + |
1474 | LittleLong (pinmodel->numverts) * sizeof (stvert_t) + | 1481 | LittleLongUnaligned (pinmodel->numverts) * sizeof (stvert_t) + |
1475 | LittleLong (pinmodel->numtris) * sizeof (mtriangle_t); | 1482 | LittleLongUnaligned (pinmodel->numtris) * sizeof (mtriangle_t); |
1476 | 1483 | ||
1477 | pheader = Hunk_AllocName (size, loadname); | 1484 | pheader = Hunk_AllocName (size, loadname); |
1478 | pmodel = (mdl_t *) ((byte *)&pheader[1] + | 1485 | pmodel = (mdl_t *) ((byte *)&pheader[1] + |
1479 | (LittleLong (pinmodel->numframes) - 1) * | 1486 | (LittleLongUnaligned (pinmodel->numframes) - 1) * |
1480 | sizeof (pheader->frames[0])); | 1487 | sizeof (pheader->frames[0])); |
1481 | 1488 | ||
1482 | // mod->cache.data = pheader; | 1489 | // mod->cache.data = pheader; |
1483 | mod->flags = LittleLong (pinmodel->flags); | 1490 | mod->flags = LittleLongUnaligned (pinmodel->flags); |
1484 | 1491 | ||
1485 | // | 1492 | // |
1486 | // endian-adjust and copy the data, starting with the alias model header | 1493 | // endian-adjust and copy the data, starting with the alias model header |
1487 | // | 1494 | // |
1488 | pmodel->boundingradius = LittleFloat (pinmodel->boundingradius); | 1495 | pmodel->boundingradius = LittleFloatUnaligned (pinmodel->boundingradius); |
1489 | pmodel->numskins = LittleLong (pinmodel->numskins); | 1496 | pmodel->numskins = LittleLongUnaligned (pinmodel->numskins); |
1490 | pmodel->skinwidth = LittleLong (pinmodel->skinwidth); | 1497 | pmodel->skinwidth = LittleLongUnaligned (pinmodel->skinwidth); |
1491 | pmodel->skinheight = LittleLong (pinmodel->skinheight); | 1498 | pmodel->skinheight = LittleLongUnaligned (pinmodel->skinheight); |
1492 | 1499 | ||
1493 | if (pmodel->skinheight > MAX_LBM_HEIGHT) | 1500 | if (pmodel->skinheight > MAX_LBM_HEIGHT) |
1494 | Sys_Error ("model %s has a skin taller than %d", mod->name, | 1501 | Sys_Error ("model %s has a skin taller than %d", mod->name, |
1495 | MAX_LBM_HEIGHT); | 1502 | MAX_LBM_HEIGHT); |
1496 | 1503 | ||
1497 | pmodel->numverts = LittleLong (pinmodel->numverts); | 1504 | pmodel->numverts = LittleLongUnaligned (pinmodel->numverts); |
1498 | 1505 | ||
1499 | if (pmodel->numverts <= 0) | 1506 | if (pmodel->numverts <= 0) |
1500 | Sys_Error ("model %s has no vertices", mod->name); | 1507 | Sys_Error ("model %s has no vertices", mod->name); |
@@ -1502,21 +1509,21 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1502 | if (pmodel->numverts > MAXALIASVERTS) | 1509 | if (pmodel->numverts > MAXALIASVERTS) |
1503 | Sys_Error ("model %s has too many vertices", mod->name); | 1510 | Sys_Error ("model %s has too many vertices", mod->name); |
1504 | 1511 | ||
1505 | pmodel->numtris = LittleLong (pinmodel->numtris); | 1512 | pmodel->numtris = LittleLongUnaligned (pinmodel->numtris); |
1506 | 1513 | ||
1507 | if (pmodel->numtris <= 0) | 1514 | if (pmodel->numtris <= 0) |
1508 | Sys_Error ("model %s has no triangles", mod->name); | 1515 | Sys_Error ("model %s has no triangles", mod->name); |
1509 | 1516 | ||
1510 | pmodel->numframes = LittleLong (pinmodel->numframes); | 1517 | pmodel->numframes = LittleLongUnaligned (pinmodel->numframes); |
1511 | pmodel->size = LittleFloat (pinmodel->size) * ALIAS_BASE_SIZE_RATIO; | 1518 | pmodel->size = LittleFloatUnaligned (pinmodel->size) * ALIAS_BASE_SIZE_RATIO; |
1512 | mod->synctype = LittleLong (pinmodel->synctype); | 1519 | mod->synctype = LittleLongUnaligned (pinmodel->synctype); |
1513 | mod->numframes = pmodel->numframes; | 1520 | mod->numframes = pmodel->numframes; |
1514 | 1521 | ||
1515 | for (i=0 ; i<3 ; i++) | 1522 | for (i=0 ; i<3 ; i++) |
1516 | { | 1523 | { |
1517 | pmodel->scale[i] = LittleFloat (pinmodel->scale[i]); | 1524 | pmodel->scale[i] = LittleFloatUnaligned (pinmodel->scale[i]); |
1518 | pmodel->scale_origin[i] = LittleFloat (pinmodel->scale_origin[i]); | 1525 | pmodel->scale_origin[i] = LittleFloatUnaligned (pinmodel->scale_origin[i]); |
1519 | pmodel->eyeposition[i] = LittleFloat (pinmodel->eyeposition[i]); | 1526 | pmodel->eyeposition[i] = LittleFloatUnaligned (pinmodel->eyeposition[i]); |
1520 | } | 1527 | } |
1521 | 1528 | ||
1522 | numskins = pmodel->numskins; | 1529 | numskins = pmodel->numskins; |
@@ -1546,7 +1553,7 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1546 | { | 1553 | { |
1547 | aliasskintype_t skintype; | 1554 | aliasskintype_t skintype; |
1548 | 1555 | ||
1549 | skintype = LittleLong (pskintype->type); | 1556 | skintype = LittleLongUnaligned (pskintype->type); |
1550 | pskindesc[i].type = skintype; | 1557 | pskindesc[i].type = skintype; |
1551 | 1558 | ||
1552 | if (skintype == ALIAS_SKIN_SINGLE) | 1559 | if (skintype == ALIAS_SKIN_SINGLE) |
@@ -1575,10 +1582,10 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1575 | 1582 | ||
1576 | for (i=0 ; i<pmodel->numverts ; i++) | 1583 | for (i=0 ; i<pmodel->numverts ; i++) |
1577 | { | 1584 | { |
1578 | pstverts[i].onseam = LittleLong (pinstverts[i].onseam); | 1585 | pstverts[i].onseam = LittleLongUnaligned (pinstverts[i].onseam); |
1579 | // put s and t in 16.16 format | 1586 | // put s and t in 16.16 format |
1580 | pstverts[i].s = LittleLong (pinstverts[i].s) << 16; | 1587 | pstverts[i].s = LittleLongUnaligned (pinstverts[i].s) << 16; |
1581 | pstverts[i].t = LittleLong (pinstverts[i].t) << 16; | 1588 | pstverts[i].t = LittleLongUnaligned (pinstverts[i].t) << 16; |
1582 | } | 1589 | } |
1583 | 1590 | ||
1584 | // | 1591 | // |
@@ -1593,12 +1600,12 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1593 | { | 1600 | { |
1594 | int j; | 1601 | int j; |
1595 | 1602 | ||
1596 | ptri[i].facesfront = LittleLong (pintriangles[i].facesfront); | 1603 | ptri[i].facesfront = LittleLongUnaligned (pintriangles[i].facesfront); |
1597 | 1604 | ||
1598 | for (j=0 ; j<3 ; j++) | 1605 | for (j=0 ; j<3 ; j++) |
1599 | { | 1606 | { |
1600 | ptri[i].vertindex[j] = | 1607 | ptri[i].vertindex[j] = |
1601 | LittleLong (pintriangles[i].vertindex[j]); | 1608 | LittleLongUnaligned (pintriangles[i].vertindex[j]); |
1602 | } | 1609 | } |
1603 | } | 1610 | } |
1604 | 1611 | ||
@@ -1614,7 +1621,7 @@ void Mod_LoadAliasModel (model_t *mod, void *buffer) | |||
1614 | { | 1621 | { |
1615 | aliasframetype_t frametype; | 1622 | aliasframetype_t frametype; |
1616 | 1623 | ||
1617 | frametype = LittleLong (pframetype->type); | 1624 | frametype = LittleLongUnaligned (pframetype->type); |
1618 | pheader->frames[i].type = frametype; | 1625 | pheader->frames[i].type = frametype; |
1619 | 1626 | ||
1620 | if (frametype == ALIAS_SINGLE) | 1627 | if (frametype == ALIAS_SINGLE) |
@@ -1676,8 +1683,8 @@ void * Mod_LoadSpriteFrame (void * pin, mspriteframe_t **ppframe) | |||
1676 | 1683 | ||
1677 | pinframe = (dspriteframe_t *)pin; | 1684 | pinframe = (dspriteframe_t *)pin; |
1678 | 1685 | ||
1679 | width = LittleLong (pinframe->width); | 1686 | width = LittleLongUnaligned (pinframe->width); |
1680 | height = LittleLong (pinframe->height); | 1687 | height = LittleLongUnaligned (pinframe->height); |
1681 | size = width * height; | 1688 | size = width * height; |
1682 | 1689 | ||
1683 | pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t) + size*r_pixbytes, | 1690 | pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t) + size*r_pixbytes, |
@@ -1688,8 +1695,8 @@ void * Mod_LoadSpriteFrame (void * pin, mspriteframe_t **ppframe) | |||
1688 | 1695 | ||
1689 | pspriteframe->width = width; | 1696 | pspriteframe->width = width; |
1690 | pspriteframe->height = height; | 1697 | pspriteframe->height = height; |
1691 | origin[0] = LittleLong (pinframe->origin[0]); | 1698 | origin[0] = LittleLongUnaligned (pinframe->origin[0]); |
1692 | origin[1] = LittleLong (pinframe->origin[1]); | 1699 | origin[1] = LittleLongUnaligned (pinframe->origin[1]); |
1693 | 1700 | ||
1694 | pspriteframe->up = origin[1]; | 1701 | pspriteframe->up = origin[1]; |
1695 | pspriteframe->down = origin[1] - height; | 1702 | pspriteframe->down = origin[1] - height; |
@@ -1734,7 +1741,7 @@ void * Mod_LoadSpriteGroup (void * pin, mspriteframe_t **ppframe) | |||
1734 | 1741 | ||
1735 | pingroup = (dspritegroup_t *)pin; | 1742 | pingroup = (dspritegroup_t *)pin; |
1736 | 1743 | ||
1737 | numframes = LittleLong (pingroup->numframes); | 1744 | numframes = LittleLongUnaligned (pingroup->numframes); |
1738 | 1745 | ||
1739 | pspritegroup = Hunk_AllocName (sizeof (mspritegroup_t) + | 1746 | pspritegroup = Hunk_AllocName (sizeof (mspritegroup_t) + |
1740 | (numframes - 1) * sizeof (pspritegroup->frames[0]), loadname); | 1747 | (numframes - 1) * sizeof (pspritegroup->frames[0]), loadname); |
@@ -1751,7 +1758,7 @@ void * Mod_LoadSpriteGroup (void * pin, mspriteframe_t **ppframe) | |||
1751 | 1758 | ||
1752 | for (i=0 ; i<numframes ; i++) | 1759 | for (i=0 ; i<numframes ; i++) |
1753 | { | 1760 | { |
1754 | *poutintervals = LittleFloat (pin_intervals->interval); | 1761 | *poutintervals = LittleFloatUnaligned (pin_intervals->interval); |
1755 | if (*poutintervals <= 0.0) | 1762 | if (*poutintervals <= 0.0) |
1756 | Sys_Error ("Mod_LoadSpriteGroup: interval<=0"); | 1763 | Sys_Error ("Mod_LoadSpriteGroup: interval<=0"); |
1757 | 1764 | ||
@@ -1787,12 +1794,12 @@ void Mod_LoadSpriteModel (model_t *mod, void *buffer) | |||
1787 | 1794 | ||
1788 | pin = (dsprite_t *)buffer; | 1795 | pin = (dsprite_t *)buffer; |
1789 | 1796 | ||
1790 | version = LittleLong (pin->version); | 1797 | version = LittleLongUnaligned (pin->version); |
1791 | if (version != SPRITE_VERSION) | 1798 | if (version != SPRITE_VERSION) |
1792 | Sys_Error ("%s has wrong version number " | 1799 | Sys_Error ("%s has wrong version number " |
1793 | "(%i should be %i)", mod->name, version, SPRITE_VERSION); | 1800 | "(%i should be %i)", mod->name, version, SPRITE_VERSION); |
1794 | 1801 | ||
1795 | numframes = LittleLong (pin->numframes); | 1802 | numframes = LittleLongUnaligned (pin->numframes); |
1796 | 1803 | ||
1797 | size = sizeof (msprite_t) + (numframes - 1) * sizeof (psprite->frames); | 1804 | size = sizeof (msprite_t) + (numframes - 1) * sizeof (psprite->frames); |
1798 | 1805 | ||
@@ -1800,11 +1807,11 @@ void Mod_LoadSpriteModel (model_t *mod, void *buffer) | |||
1800 | 1807 | ||
1801 | mod->cache.data = psprite; | 1808 | mod->cache.data = psprite; |
1802 | 1809 | ||
1803 | psprite->type = LittleLong (pin->type); | 1810 | psprite->type = LittleLongUnaligned (pin->type); |
1804 | psprite->maxwidth = LittleLong (pin->width); | 1811 | psprite->maxwidth = LittleLongUnaligned (pin->width); |
1805 | psprite->maxheight = LittleLong (pin->height); | 1812 | psprite->maxheight = LittleLongUnaligned (pin->height); |
1806 | psprite->beamlength = LittleFloat (pin->beamlength); | 1813 | psprite->beamlength = LittleFloatUnaligned (pin->beamlength); |
1807 | mod->synctype = LittleLong (pin->synctype); | 1814 | mod->synctype = LittleLongUnaligned (pin->synctype); |
1808 | psprite->numframes = numframes; | 1815 | psprite->numframes = numframes; |
1809 | 1816 | ||
1810 | mod->mins[0] = mod->mins[1] = -psprite->maxwidth/2; | 1817 | mod->mins[0] = mod->mins[1] = -psprite->maxwidth/2; |
@@ -1827,7 +1834,7 @@ void Mod_LoadSpriteModel (model_t *mod, void *buffer) | |||
1827 | { | 1834 | { |
1828 | spriteframetype_t frametype; | 1835 | spriteframetype_t frametype; |
1829 | 1836 | ||
1830 | frametype = LittleLong (pframetype->type); | 1837 | frametype = LittleLongUnaligned (pframetype->type); |
1831 | psprite->frames[i].type = frametype; | 1838 | psprite->frames[i].type = frametype; |
1832 | 1839 | ||
1833 | if (frametype == SPR_SINGLE) | 1840 | if (frametype == SPR_SINGLE) |