From 7950c38a5dc5b489d75ae1ff5263e3f38a4c4089 Mon Sep 17 00:00:00 2001 From: tigital Date: Thu, 10 Jun 2004 23:58:45 +0000 Subject: [PATCH] byte-swapping changes for bigendian systems --- include/modelsinc.h | 5 + include/multimsgs.h | 17 ++- src/model/modelread.cpp | 240 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 260 insertions(+), 2 deletions(-) diff --git a/include/modelsinc.h b/include/modelsinc.h index e134343..510edf1 100644 --- a/include/modelsinc.h +++ b/include/modelsinc.h @@ -76,6 +76,11 @@ void model_calc_bound_box( vector *box, vector *big_mn, vector *big_mx); void interp_clear_instance(); +#if SDL_BYTEORDER == SDL_BIG_ENDIAN +// Endian swapping stuff tigital +void swap_bsp_data( polymodel * pm, void *model_ptr ); +#endif + #define MAX_POLYGON_VECS 1100 //6500 (7x) #define MAX_POLYGON_NORMS 2800 //6500 (3x) diff --git a/include/multimsgs.h b/include/multimsgs.h index ee46a08..81f5fae 100644 --- a/include/multimsgs.h +++ b/include/multimsgs.h @@ -15,6 +15,9 @@ * Header file for the building and sending of multiplayer packets * * $Log$ + * Revision 1.6 2004/06/10 23:58:45 tigital + * byte-swapping changes for bigendian systems + * * Revision 1.5 2003/01/30 19:46:18 relnev * use psnet.h instead of psnet2.h to go inline with everything else (Taylor Richards) * @@ -246,11 +249,21 @@ struct ship_subsys; #define BUILD_HEADER(t) do { data[0]=t; packet_size = HEADER_LENGTH; } while(0) #define ADD_DATA(d) do { Assert((packet_size + sizeof(d)) < MAX_PACKET_SIZE); memcpy(data+packet_size, &d, sizeof(d) ); packet_size += sizeof(d); } while (0) -#define ADD_STRING(s) do { Assert((packet_size + strlen(s) + 4) < MAX_PACKET_SIZE);int len = strlen(s); ADD_DATA(len); memcpy(data+packet_size, s, len ); packet_size += len; } while(0) +#define ADD_DATA_S16(d) do { Assert((packet_size + sizeof(d)) < MAX_PACKET_SIZE); short swap = INTEL_SHORT(d); memcpy(data+packet_size, &swap, sizeof(d) ); packet_size += sizeof(d); } while (0) +#define ADD_DATA_U16(d) do { Assert((packet_size + sizeof(d)) < MAX_PACKET_SIZE); ushort swap = INTEL_SHORT(d); memcpy(data+packet_size, &swap, sizeof(d) ); packet_size += sizeof(d); } while (0) +#define ADD_DATA_S32(d) do { Assert((packet_size + sizeof(d)) < MAX_PACKET_SIZE); int swap = INTEL_INT(d); memcpy(data+packet_size, &swap, sizeof(d) ); packet_size += sizeof(d); } while (0) +#define ADD_DATA_U32(d) do { Assert((packet_size + sizeof(d)) < MAX_PACKET_SIZE); uint swap = INTEL_INT(d); memcpy(data+packet_size, &swap, sizeof(d) ); packet_size += sizeof(d); } while (0) +#define ADD_DATA_FL(d) do { Assert((packet_size + sizeof(d)) < MAX_PACKET_SIZE); float swap = INTEL_FLOAT(&d); memcpy(data+packet_size, &swap, sizeof(d) ); packet_size += sizeof(d); } while (0) +#define ADD_STRING(s) do { Assert((packet_size + strlen(s) + 4) < MAX_PACKET_SIZE);int len = strlen(s); int len_tmp = INTEL_INT(len); ADD_DATA(len_tmp); memcpy(data+packet_size, s, len ); packet_size += len; } while(0) #define ADD_ORIENT(d) { Assert((packet_size + 17) < MAX_PACKET_SIZE); ubyte dt[17]; multi_pack_orient_matrix(dt,&d); memcpy(data+packet_size,dt,17); packet_size += 17; } #define GET_DATA(d) do { memcpy(&d, data+offset, sizeof(d) ); offset += sizeof(d); } while(0) -#define GET_STRING(s) do { int len; memcpy(&len, data+offset, sizeof(len)); offset += sizeof(len); memcpy(s, data+offset, len); offset += len; s[len] = '\0'; } while(0) +#define GET_DATA_S16(d) do { short swap; memcpy(&swap, data+offset, sizeof(d) ); d = INTEL_SHORT(swap); offset += sizeof(d); } while(0) +#define GET_DATA_U16(d) do { ushort swap; memcpy(&swap, data+offset, sizeof(d) ); d = INTEL_SHORT(swap); offset += sizeof(d); } while(0) +#define GET_DATA_S32(d) do { int swap; memcpy(&swap, data+offset, sizeof(d) ); d = INTEL_INT(swap); offset += sizeof(d); } while(0) +#define GET_DATA_U32(d) do { uint swap; memcpy(&swap, data+offset, sizeof(d) ); d = INTEL_INT(swap); offset += sizeof(d); } while(0) +#define GET_DATA_FL(d) do { float swap; memcpy(&swap, data+offset, sizeof(d) ); d = INTEL_FLOAT(&swap); offset += sizeof(d); } while(0) +#define GET_STRING(s) do { int len; memcpy(&len, data+offset, sizeof(len)); len = INTEL_INT(len); offset += sizeof(len); memcpy(s, data+offset, len); offset += len; s[len] = '\0'; } while(0) #define GET_ORIENT(d) { ubyte dt[17]; memcpy(dt,data+offset,17); offset+=17; multi_unpack_orient_matrix(dt,&d); } #define PACKET_SET_SIZE() do { hinfo->bytes_processed = offset; } while(0) diff --git a/src/model/modelread.cpp b/src/model/modelread.cpp index da417a9..31adfcc 100644 --- a/src/model/modelread.cpp +++ b/src/model/modelread.cpp @@ -15,6 +15,9 @@ * file which reads and deciphers POF information * * $Log$ + * Revision 1.9 2004/06/10 23:55:39 tigital + * byte-swapping changes for bigendian systems + * * Revision 1.8 2003/06/11 18:30:33 taylor * plug memory leaks * @@ -710,6 +713,10 @@ #include "freespace.h" // For flFrameTime #include "fvi.h" +#ifdef __APPLE__ +#include // tigital for offsetof() +#endif + #define MAX_SUBMODEL_COLLISION_ROT_ANGLE (PI / 6.0f) // max 30 degrees per frame // info for special polygon lists @@ -1524,6 +1531,9 @@ int read_model_file(polymodel * pm, char *filename, int n_subsystems, model_subs if ( pm->submodel[n].bsp_data_size > 0 ) { pm->submodel[n].bsp_data = (ubyte *)malloc(pm->submodel[n].bsp_data_size); cfread(pm->submodel[n].bsp_data,1,pm->submodel[n].bsp_data_size,fp); + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) //tigital + swap_bsp_data( pm, pm->submodel[n].bsp_data ); + } else { pm->submodel[n].bsp_data = NULL; } @@ -3471,3 +3481,233 @@ int model_get_num_dock_points(int modelnum) return pm->n_docks; } +#if SDL_BYTEORDER == SDL_BIG_ENDIAN // tigital +void swap_bsp_defpoints(ubyte * p) +{ + int n, i; + int nverts = INTEL_INT( w(p+8) ); + w(p+8) = nverts; + int offset = INTEL_INT( w(p+16) ); + w(p+16) = offset; + int n_norms = INTEL_INT( w(p+12) ); + w(p+12) = n_norms; + + ubyte * normcount = p+20; + vector *src = vp(p+offset); + + Assert( nverts < MAX_POLYGON_VECS ); + // Assert( nnorms < MAX_POLYGON_NORMS ); + + for (n=0; nxyz.x = INTEL_FLOAT( &src->xyz.x ); + src->xyz.y = INTEL_FLOAT( &src->xyz.y ); + src->xyz.z = INTEL_FLOAT( &src->xyz.z ); + + Interp_verts[n] = src; + src++; + for (i=0;ixyz.x = INTEL_FLOAT( &src->xyz.x ); + src->xyz.y = INTEL_FLOAT( &src->xyz.y ); + src->xyz.z = INTEL_FLOAT( &src->xyz.z ); + src++; + } + + } +} +void swap_bsp_tmappoly( polymodel * pm, ubyte * p ) +{ + int i, nv; + model_tmap_vert *verts; + vector * normal = vp(p+8); + vector * center = vp(p+20); + float radius = INTEL_FLOAT( &fl(p+32) ); + fl(p+32) = radius; + normal->xyz.x = INTEL_FLOAT( &normal->xyz.x ); + normal->xyz.y = INTEL_FLOAT( &normal->xyz.y ); + normal->xyz.z = INTEL_FLOAT( &normal->xyz.z ); + center->xyz.x = INTEL_FLOAT( ¢er->xyz.x ); + center->xyz.y = INTEL_FLOAT( ¢er->xyz.y ); + center->xyz.z = INTEL_FLOAT( ¢er->xyz.z ); + + nv = INTEL_INT( w(p+36)); + w(p+36) = nv; + int tmap_num = INTEL_INT( w(p+40) ); + w(p+40) = tmap_num; + + if ( nv < 0 ) return; + + verts = (model_tmap_vert *)(p+44); + for (i=0;iversion < 2003 ) { + // Set the "normal_point" part of field to be the center of the polygon + vector center_point; + vm_vec_zero( ¢er_point ); + + for (i=0;i rad ) { + rad = dist; + } + } + fl(p+32) = rad; + } +} +void swap_bsp_flatpoly( polymodel * pm, ubyte * p ) +{ + int i, nv; + short *verts; + vector * normal = vp(p+8); + vector * center = vp(p+20); + float radius = INTEL_FLOAT( &fl(p+32) ); + fl(p+32) = radius; + mprintf(("flatpoly radius = %f\n", radius )); + normal->xyz.x = INTEL_FLOAT( &normal->xyz.x ); + normal->xyz.y = INTEL_FLOAT( &normal->xyz.y ); + normal->xyz.z = INTEL_FLOAT( &normal->xyz.z ); + center->xyz.x = INTEL_FLOAT( ¢er->xyz.x ); + center->xyz.y = INTEL_FLOAT( ¢er->xyz.y ); + center->xyz.z = INTEL_FLOAT( ¢er->xyz.z ); + + nv = INTEL_INT( w(p+36)); //tigital + w(p+36) = nv; + + if ( nv < 0 ) return; + + verts = (short *)(p+44); + for (i=0; iversion < 2003 ) { + // Set the "normal_point" part of field to be the center of the polygon + vector center_point; + vm_vec_zero( ¢er_point ); + + for (i=0;i rad ) { + rad = dist; + } + } + fl(p+32) = rad; + } +} +void swap_bsp_sortnorms( polymodel * pm, ubyte * p ) +{ + int frontlist = INTEL_INT( w(p+36) ); + int backlist = INTEL_INT( w(p+40) ); + int prelist = INTEL_INT( w(p+44) ); + int postlist = INTEL_INT( w(p+48) ); + int onlist = INTEL_INT( w(p+52) ); + w(p+36) = frontlist; + w(p+40) = backlist; + w(p+44) = prelist; + w(p+48) = postlist; + w(p+52) = onlist; + + vector * normal = vp(p+8); + vector * center = vp(p+20); + int tmp = INTEL_INT( w(p+32) ); + w(p+32) = tmp; + normal->xyz.x = INTEL_FLOAT( &normal->xyz.x ); + normal->xyz.y = INTEL_FLOAT( &normal->xyz.y ); + normal->xyz.z = INTEL_FLOAT( &normal->xyz.z ); + center->xyz.x = INTEL_FLOAT( ¢er->xyz.x ); + center->xyz.y = INTEL_FLOAT( ¢er->xyz.y ); + center->xyz.z = INTEL_FLOAT( ¢er->xyz.z ); + + vector * bmin = vp(p+56); + vector * bmax = vp(p+68); + bmin->xyz.x = INTEL_FLOAT( &bmin->xyz.x ); + bmin->xyz.y = INTEL_FLOAT( &bmin->xyz.y ); + bmin->xyz.z = INTEL_FLOAT( &bmin->xyz.z ); + bmax->xyz.x = INTEL_FLOAT( &bmax->xyz.x ); + bmax->xyz.y = INTEL_FLOAT( &bmax->xyz.y ); + bmax->xyz.z = INTEL_FLOAT( &bmax->xyz.z ); + + if (prelist) swap_bsp_data(pm,p+prelist); + if (backlist) swap_bsp_data(pm,p+backlist); + if (onlist) swap_bsp_data(pm,p+onlist); + if (frontlist) swap_bsp_data(pm,p+frontlist); + if (postlist) swap_bsp_data(pm,p+postlist); +} +void swap_bsp_data( polymodel * pm, void *model_ptr ) +{ + ubyte *p = (ubyte *)model_ptr; + int chunk_type, chunk_size; + vector * min; + vector * max; + + chunk_type = INTEL_INT( w(p) ); + chunk_size = INTEL_INT( w(p+4) ); + w(p) = chunk_type; + w(p+4) = chunk_size; + + while (chunk_type != OP_EOF) { + + switch (chunk_type) { + case OP_EOF: + return; + case OP_DEFPOINTS: + swap_bsp_defpoints(p); + break; + case OP_FLATPOLY: + swap_bsp_flatpoly(pm, p ); break; + case OP_TMAPPOLY: + swap_bsp_tmappoly(pm, p ); break; + case OP_SORTNORM: + swap_bsp_sortnorms(pm,p ); break; + case OP_BOUNDBOX: + min = vp(p+8); + max = vp(p+20); + min->xyz.x = INTEL_FLOAT( &min->xyz.x ); + min->xyz.y = INTEL_FLOAT( &min->xyz.y ); + min->xyz.z = INTEL_FLOAT( &min->xyz.z ); + max->xyz.x = INTEL_FLOAT( &max->xyz.x ); + max->xyz.y = INTEL_FLOAT( &max->xyz.y ); + max->xyz.z = INTEL_FLOAT( &max->xyz.z ); + break; + default: + mprintf(( "Bad chunk type %d, len=%d in modelread:swap_bsp_data\n", chunk_type, chunk_size )); + Int3(); // Bad chunk type! + return; + } + p += chunk_size; + chunk_type = INTEL_INT( w(p)); + chunk_size = INTEL_INT( w(p+4) ); + w(p) = chunk_type; + w(p+4) = chunk_size; + } + return; +} +#endif // SDL_BYTEORDER == SDL_BIG_ENDIAN -- 2.39.2