1 #include <math.h> 2 3 #include "list_tem.hpp" 4 5 #include "zsp.hpp" 6 ~ZSP_Data()7ZSP_Data::~ZSP_Data() 8 { 9 while (zone_array.size()) 10 { 11 zone_array.delete_first_entry(); 12 } 13 } 14 ZSP_Data(const char * zdata,size_t)15ZSP_Data::ZSP_Data (const char * zdata, size_t /*zsize*/) 16 { 17 const char * ptr = zdata; 18 19 num_x_cubes = *((int *) ptr); 20 ptr += 4; 21 22 num_y_cubes = *((int *) ptr); 23 ptr += 4; 24 25 num_z_cubes = *((int *) ptr); 26 ptr += 4; 27 28 cube_size = *((double *) ptr); 29 ptr += 8; 30 31 cube_radius = *((double *) ptr); 32 ptr += 8; 33 34 int i,j; 35 36 int numzones = num_x_cubes*num_y_cubes*num_z_cubes; 37 38 for (i=0; i<numzones; i++) 39 { 40 ZSP_zone tmpzone; 41 42 tmpzone.num_z_polys = *((int *) ptr); 43 ptr += 4; 44 45 tmpzone.num_z_verts = *((int *) ptr); 46 ptr += 4; 47 48 if (tmpzone.num_z_polys) 49 tmpzone.z_poly_list = new int [tmpzone.num_z_polys]; 50 51 for (j=0; j<tmpzone.num_z_polys; j++) 52 { 53 tmpzone.z_poly_list[j] = *((int *) ptr); 54 ptr += 4; 55 } 56 57 if (tmpzone.num_z_verts) 58 tmpzone.z_vert_list = new int [tmpzone.num_z_verts]; 59 60 for (j=0; j<tmpzone.num_z_verts; j++) 61 { 62 tmpzone.z_vert_list[j] = *((int *) ptr); 63 ptr += 4; 64 } 65 66 zone_array.add_entry(tmpzone); 67 } 68 69 } 70 71 ZSP_zone()72ZSP_zone::ZSP_zone () 73 { 74 num_z_polys = 0; 75 z_poly_list = 0; 76 num_z_verts = 0; 77 z_vert_list = 0; 78 } 79 ~ZSP_zone()80ZSP_zone::~ZSP_zone () 81 { 82 if (num_z_polys) 83 delete [] z_poly_list; 84 if (num_z_verts) 85 delete [] z_vert_list; 86 } 87 ZSP_zone(const ZSP_zone & zz)88ZSP_zone::ZSP_zone (const ZSP_zone &zz) 89 { 90 if (zz.num_z_polys) 91 { 92 num_z_polys = zz.num_z_polys; 93 z_poly_list = new int [num_z_polys]; 94 95 int i; 96 97 for (i=0; i<num_z_polys; i++) 98 { 99 z_poly_list[i] = zz.z_poly_list[i]; 100 } 101 } 102 else 103 { 104 z_poly_list = 0; 105 num_z_polys = 0; 106 } 107 108 109 if (zz.num_z_verts) 110 { 111 num_z_verts = zz.num_z_verts; 112 z_vert_list = new int [num_z_verts]; 113 114 int i; 115 116 for (i=0; i<num_z_verts; i++) 117 { 118 z_vert_list[i] = zz.z_vert_list[i]; 119 } 120 } 121 else 122 { 123 z_vert_list = 0; 124 num_z_verts = 0; 125 } 126 127 } 128 operator =(const ZSP_zone & zz)129ZSP_zone & ZSP_zone::operator=(const ZSP_zone &zz) 130 { 131 132 if (num_z_polys) 133 delete [] z_poly_list; 134 if (num_z_verts) 135 delete [] z_vert_list; 136 137 if (zz.num_z_polys) 138 { 139 num_z_polys = zz.num_z_polys; 140 z_poly_list = new int [num_z_polys]; 141 142 int i; 143 144 for (i=0; i<num_z_polys; i++) 145 { 146 z_poly_list[i] = zz.z_poly_list[i]; 147 } 148 } 149 else 150 { 151 z_poly_list = 0; 152 num_z_polys = 0; 153 } 154 155 156 if (zz.num_z_verts) 157 { 158 num_z_verts = zz.num_z_verts; 159 z_vert_list = new int [num_z_verts]; 160 161 int i; 162 163 for (i=0; i<num_z_verts; i++) 164 { 165 z_vert_list[i] = zz.z_vert_list[i]; 166 } 167 } 168 else 169 { 170 z_vert_list = 0; 171 num_z_verts = 0; 172 } 173 174 return(*this); 175 176 } 177 178 operator ==(const ZSP_zone & z1,const ZSP_zone & z2)179unsigned char operator==(const ZSP_zone &z1, const ZSP_zone &z2) 180 { 181 return(&z1 == &z2); 182 } 183 operator !=(const ZSP_zone & z1,const ZSP_zone & z2)184unsigned char operator!=(const ZSP_zone &z1, const ZSP_zone &z2) 185 { 186 return(&z1 != &z2); 187 } 188 189 190 191 ///////////////////////////////////////// 192 193 // Class Shape_ZSP_Data_Chunk functions 194 size_chunk()195size_t Shape_ZSP_Data_Chunk::size_chunk () 196 { 197 int sz = 12 + 12 + 16; 198 199 ZSP_Data * zdata = (ZSP_Data *)(&zspdata); 200 201 for (LIF<ZSP_zone> znl(&zdata->zone_array); !znl.done(); znl.next()) 202 { 203 sz += 8 + (znl().num_z_polys * 4) + (znl().num_z_verts * 4); 204 } 205 206 return (chunk_size = sz); 207 } 208 fill_data_block(char * data_start)209void Shape_ZSP_Data_Chunk::fill_data_block ( char * data_start) 210 { 211 strncpy (data_start, identifier, 8); 212 213 data_start += 8; 214 215 *((int *) data_start) = chunk_size; 216 217 data_start += 4; 218 219 *((int *) data_start) = zspdata.num_x_cubes; 220 data_start += 4; 221 222 *((int *) data_start) = zspdata.num_y_cubes; 223 data_start += 4; 224 225 *((int *) data_start) = zspdata.num_z_cubes; 226 data_start += 4; 227 228 *((double *) data_start) = zspdata.cube_size; 229 data_start += 8; 230 231 *((double *) data_start) = zspdata.cube_radius; 232 data_start += 8; 233 234 ZSP_Data * zdata = (ZSP_Data *)(&zspdata); 235 236 for (LIF<ZSP_zone> znl(&zdata->zone_array); !znl.done(); znl.next()) 237 { 238 *((int *) data_start) = znl().num_z_polys; 239 data_start += 4; 240 241 *((int *) data_start) = znl().num_z_verts; 242 data_start += 4; 243 244 int i; 245 for (i=0; i<znl().num_z_polys; i++) 246 { 247 *((int *) data_start) = znl().z_poly_list[i]; 248 data_start += 4; 249 } 250 251 for (i=0; i<znl().num_z_verts; i++) 252 { 253 *((int *) data_start) = znl().z_vert_list[i]; 254 data_start += 4; 255 } 256 } 257 } 258