1 #include <math.h>
2 
3 #include "list_tem.hpp"
4 
5 #include "zsp.hpp"
6 
~ZSP_Data()7 ZSP_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)15 ZSP_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()72 ZSP_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()80 ZSP_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)88 ZSP_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)129 ZSP_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)179 unsigned 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)184 unsigned 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()195 size_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)209 void 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