diff options
author | Franklin Wei <git@fwei.tk> | 2019-07-20 20:40:51 -0400 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2019-07-21 15:13:35 -0400 |
commit | ef9ee8935f3ec95a636272cf6c19f55573f5ee6d (patch) | |
tree | 6e60715ec8a909004a87afc0839efaa22d27f50a /apps/plugins/sdl/progs/quake/model.c | |
parent | 2ca47176f9fffade0569a0c18f75536cd020a19c (diff) | |
download | rockbox-ef9ee8935f3ec95a636272cf6c19f55573f5ee6d.tar.gz rockbox-ef9ee8935f3ec95a636272cf6c19f55573f5ee6d.zip |
quake: fix unaligned accesses in model.c
Allows playing registered episodes.
Change-Id: I20e1ca2000776a19767a9c3caef790d4f62ca188
Diffstat (limited to 'apps/plugins/sdl/progs/quake/model.c')
-rw-r--r-- | apps/plugins/sdl/progs/quake/model.c | 191 |
1 files changed, 99 insertions, 92 deletions
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) |