From 2186d5f3f95cd74a070a490d899291648d58667a Mon Sep 17 00:00:00 2001
From: Steven Fuller <relnev@icculus.org>
Date: Sun, 1 Jul 2001 00:55:22 +0000
Subject: Initial revision

---
 src/win95/zsp.cpp | 511 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 511 insertions(+)
 create mode 100644 src/win95/zsp.cpp

(limited to 'src/win95/zsp.cpp')

diff --git a/src/win95/zsp.cpp b/src/win95/zsp.cpp
new file mode 100644
index 0000000..1484812
--- /dev/null
+++ b/src/win95/zsp.cpp
@@ -0,0 +1,511 @@
+#include <math.h>
+
+#if cencon
+#include "AFXWIN.H"
+#include "list_tem.hpp"
+
+#include "Vectors.hpp"
+#include "environs.hpp"
+#include "shpchunk.hpp"
+#elif shpedit
+#include "list_tem.hpp"
+#include "Vectors.hpp"
+#else
+#include "list_tem.hpp"
+#endif
+
+#include "zsp.hpp"
+
+#ifdef cencon
+#define new my_new
+#endif
+
+#if shpedit
+#define twprintf printf
+#endif
+
+// ZSP creation functions
+
+#if cencon
+void generate_zsp_data (int num_cubes, CWnd * pWnd)
+{
+	Shape_Chunk * shpch = Sel_Obj->get_assoc_shape();
+
+	if (!shpch->lock_chunk(*(Main_Env.environment)))
+	{
+		char message[300];
+		char * locker = "Unknown";
+		
+		Shape_Header_Chunk * head = shpch->get_header();
+		if (head)
+			locker = head->lock_user;
+		
+		sprintf (message, "Shape locked by %s\n can not continue", locker);
+		
+		pWnd->MessageBox (message, "Tools Control Area", 
+			MB_ICONHAND + MB_OK + MB_TASKMODAL);
+		return;		
+	}
+	start_text_window(pWnd);	
+
+	
+	ZSP_Data * zsp = new ZSP_Data (shpch->shape_data, num_cubes);
+	new Shape_ZSP_Data_Chunk (shpch, *zsp);
+
+	shpch->unlock_chunk (*(Main_Env.environment), TRUE);
+	stop_text_window();
+
+	delete zsp;
+}
+#endif
+
+#if cencon || shpedit
+
+ZSP_Data::ZSP_Data (const ChunkShape & shp, int num_cubes)
+{
+	double xsize,ysize,zsize;
+	double max_size;
+	Vector cube_vector;
+	int num_subshapes;
+	
+	xsize = fabs(shp.max.x) + fabs(shp.min.x);
+	ysize = fabs(shp.max.y) + fabs(shp.min.y);
+	zsize = fabs(shp.max.z) + fabs(shp.min.z);
+	
+	max_size=max(xsize,ysize);
+	max_size=max(max_size,zsize);
+	
+	cube_size = max_size / num_cubes;
+	
+	int nc = num_cubes+2;
+	
+	num_x_cubes = nc-(int) ( nc-(xsize / cube_size) );
+	num_y_cubes = nc-(int) ( nc-(ysize / cube_size) );
+	num_z_cubes = nc-(int) ( nc-(zsize / cube_size) );
+	
+	cube_vector.x = cube_size / 2;
+	cube_vector.y = cube_size / 2;
+	cube_vector.z = cube_size / 2;
+	cube_radius = mod(cube_vector);
+	
+	num_subshapes = num_x_cubes * num_y_cubes * num_z_cubes;
+
+	int i,j,k;
+	double xstart, ystart, zstart;
+	double xstart_tmp, ystart_tmp, zstart_tmp;
+	
+
+	xstart = shp.min.x;
+	ystart = shp.min.y;
+	zstart = shp.min.z;
+
+	xstart_tmp = xstart;
+	
+	twprintf ("Number of zones is \n",num_subshapes);
+
+	for(i = 0; i < num_x_cubes; i++) {
+
+		twprintf ("x = %d\n",i);
+		
+		ystart_tmp = ystart;
+
+		for(j = 0; j < num_y_cubes; j++) {
+
+			twprintf ("y = %d\nz = ",j);
+			
+			zstart_tmp = zstart;
+
+			for(k = 0; k < num_z_cubes; k++) {
+
+				twprintf ("%d ",k);
+			
+				/* Process the subshape and update the ZSP pointer array */
+
+				ZSP_zone temp_zone(shp, xstart_tmp, ystart_tmp, 
+											zstart_tmp, cube_size);
+											
+				zone_array.add_entry(temp_zone);		
+
+				zstart_tmp += cube_size;
+
+			}
+
+			twprintf ("\n");
+
+			ystart_tmp += cube_size;
+
+		}
+
+		xstart_tmp += cube_size;
+
+	}
+
+
+	
+}
+
+	
+
+static int zone_polygons[20000];
+static unsigned char vertex_outcode [20000];
+	
+ZSP_zone::ZSP_zone (const ChunkShape & shp, double xstart, double ystart, 
+				double zstart, double cube_size)
+{
+	double xplane0, xplane1;
+	double yplane0, yplane1;
+	double zplane0, zplane1;
+	int i,j;
+	int outcode_or, outcode_and;
+	int vert_outcode;
+
+	num_z_polys = 0;
+	num_z_verts = 0;
+
+	/* Bounding planes in terms of axis limits */
+
+	xplane0 = xstart;
+	xplane1 = xstart + cube_size;
+
+	yplane0 = ystart;
+	yplane1 = ystart + cube_size;
+
+	zplane0 = zstart;
+	zplane1 = zstart + cube_size;
+
+	for (i=0; i<shp.num_polys; i++)
+	{
+		for (j=0; j<shp.poly_list[i].num_verts; j++)
+		{
+			vert_outcode = 0;
+			
+			int point_no = shp.poly_list[i].vert_ind[j];
+			
+			if(shp.v_list[point_no].x < xplane0) vert_outcode |= rsp_oc_x0;
+			if(shp.v_list[point_no].x > xplane1) vert_outcode |= rsp_oc_x1;
+			if(shp.v_list[point_no].y < yplane0) vert_outcode |= rsp_oc_y0;
+			if(shp.v_list[point_no].y > yplane1) vert_outcode |= rsp_oc_y1;
+			if(shp.v_list[point_no].z < zplane0) vert_outcode |= rsp_oc_z0;
+			if(shp.v_list[point_no].z > zplane1) vert_outcode |= rsp_oc_z1;
+
+			if(j==0) {
+
+				outcode_or  = vert_outcode;
+				outcode_and = vert_outcode;
+
+			}
+
+			else {
+
+				outcode_or  |= vert_outcode;
+				outcode_and &= vert_outcode;
+
+			}
+			
+		}
+		
+		if (outcode_and == 0)
+		{
+			zone_polygons[num_z_polys] = i;
+			num_z_polys++;
+		}
+		
+	}
+	
+	if (!num_z_polys)
+	{
+		z_poly_list=0;
+		z_vert_list=0;
+		return;
+	}
+	
+	z_poly_list = new int [num_z_polys];
+	for (i=0; i<num_z_polys; i++)
+	{
+		z_poly_list[i] = zone_polygons[i];
+	}
+	
+	for (i=0; i<shp.num_verts; i++)
+	{
+		vertex_outcode[i] = 0;
+	}
+	
+	for (i=0; i<num_z_polys; i++)
+	{
+		for (j=0; j<shp.poly_list[z_poly_list[i]].num_verts; j++)
+		{
+			vertex_outcode[shp.poly_list[z_poly_list[i]].vert_ind[j]] = 1;
+		}
+	}
+
+	for (i=0; i<shp.num_verts; i++)
+	{
+		if (vertex_outcode[i]) num_z_verts++;
+	}
+	
+	z_vert_list = new int[num_z_verts];
+	
+	j=0;
+	
+	for (i=0; i<shp.num_verts; i++)
+	{
+		if (vertex_outcode[i]) 
+			z_vert_list[j++] = i;
+	}
+
+}
+
+#endif
+
+
+ZSP_Data::~ZSP_Data()
+{
+	while (zone_array.size())
+	{
+		zone_array.delete_first_entry();
+	}
+}
+
+ZSP_Data::ZSP_Data (const char * zdata, size_t /*zsize*/)
+{
+	const char * ptr = zdata;
+
+	num_x_cubes = *((int *) ptr);
+	ptr += 4;
+
+	num_y_cubes = *((int *) ptr);
+	ptr += 4;
+
+	num_z_cubes = *((int *) ptr);
+	ptr += 4;
+
+	cube_size = *((double *) ptr);
+	ptr += 8;
+
+	cube_radius = *((double *) ptr);
+	ptr += 8;
+	
+	int i,j;
+	
+	int numzones = num_x_cubes*num_y_cubes*num_z_cubes;
+	
+	for (i=0; i<numzones; i++)
+	{
+		ZSP_zone tmpzone;
+	
+		tmpzone.num_z_polys = *((int *) ptr);
+		ptr += 4;
+
+		tmpzone.num_z_verts = *((int *) ptr);
+		ptr += 4;
+		
+		if (tmpzone.num_z_polys)
+			tmpzone.z_poly_list = new int [tmpzone.num_z_polys];
+		
+		for (j=0; j<tmpzone.num_z_polys; j++)
+		{
+			tmpzone.z_poly_list[j] = *((int *) ptr);
+			ptr += 4;
+		}
+		
+		if (tmpzone.num_z_verts)
+			tmpzone.z_vert_list = new int [tmpzone.num_z_verts];
+		
+		for (j=0; j<tmpzone.num_z_verts; j++)
+		{
+			tmpzone.z_vert_list[j] = *((int *) ptr);
+			ptr += 4;
+		}
+		
+		zone_array.add_entry(tmpzone);
+	}
+
+}	
+
+
+ZSP_zone::ZSP_zone ()
+{
+	num_z_polys = 0;
+	z_poly_list = 0;
+	num_z_verts = 0;
+	z_vert_list = 0;
+}	
+
+ZSP_zone::~ZSP_zone ()
+{
+	if (num_z_polys)
+		delete [] z_poly_list;
+	if (num_z_verts)
+		delete [] z_vert_list;
+}	
+
+ZSP_zone::ZSP_zone (const ZSP_zone &zz)
+{
+	if (zz.num_z_polys)	
+	{
+		num_z_polys = zz.num_z_polys;
+		z_poly_list = new int [num_z_polys];
+		
+		int i;
+		
+		for (i=0; i<num_z_polys; i++)
+		{
+			z_poly_list[i] = zz.z_poly_list[i];
+		}
+	}
+	else
+	{
+		z_poly_list = 0;
+		num_z_polys = 0;
+	}
+
+
+	if (zz.num_z_verts)	
+	{
+		num_z_verts = zz.num_z_verts;
+		z_vert_list = new int [num_z_verts];
+		
+		int i;
+		
+		for (i=0; i<num_z_verts; i++)
+		{
+			z_vert_list[i] = zz.z_vert_list[i];
+		}
+	}
+	else
+	{
+		z_vert_list = 0;
+		num_z_verts = 0;
+	}
+	
+}
+
+ZSP_zone & ZSP_zone::operator=(const ZSP_zone &zz)
+{
+	
+	if (num_z_polys)
+		delete [] z_poly_list;
+	if (num_z_verts)
+		delete [] z_vert_list;
+
+	if (zz.num_z_polys)	
+	{
+		num_z_polys = zz.num_z_polys;
+		z_poly_list = new int [num_z_polys];
+		
+		int i;
+		
+		for (i=0; i<num_z_polys; i++)
+		{
+			z_poly_list[i] = zz.z_poly_list[i];
+		}
+	}
+	else
+	{
+		z_poly_list = 0;
+		num_z_polys = 0;
+	}
+
+
+	if (zz.num_z_verts)	
+	{
+		num_z_verts = zz.num_z_verts;
+		z_vert_list = new int [num_z_verts];
+		
+		int i;
+		
+		for (i=0; i<num_z_verts; i++)
+		{
+			z_vert_list[i] = zz.z_vert_list[i];
+		}
+	}
+	else
+	{
+		z_vert_list = 0;
+		num_z_verts = 0;
+	}
+	
+	return(*this);
+	
+}
+	
+
+unsigned char operator==(const ZSP_zone &z1, const ZSP_zone &z2)
+{
+	return(&z1 == &z2);
+}	
+
+unsigned char operator!=(const ZSP_zone &z1, const ZSP_zone &z2)
+{
+	return(&z1 != &z2);
+}	
+
+
+
+/////////////////////////////////////////
+
+// Class Shape_ZSP_Data_Chunk functions
+
+size_t Shape_ZSP_Data_Chunk::size_chunk ()
+{
+	int sz = 12 + 12 + 16;
+
+	ZSP_Data * zdata = (ZSP_Data *)(&zspdata);
+
+	for (LIF<ZSP_zone> znl(&zdata->zone_array); !znl.done(); znl.next())
+	{
+		sz += 8 + (znl().num_z_polys * 4) + (znl().num_z_verts * 4);
+	}
+
+	return (chunk_size = sz);
+}
+
+void Shape_ZSP_Data_Chunk::fill_data_block ( char * data_start)
+{
+	strncpy (data_start, identifier, 8);
+
+	data_start += 8;
+
+	*((int *) data_start) = chunk_size;
+
+	data_start += 4;
+
+	*((int *) data_start) = zspdata.num_x_cubes;
+	data_start += 4;
+	
+	*((int *) data_start) = zspdata.num_y_cubes;
+	data_start += 4;
+
+	*((int *) data_start) = zspdata.num_z_cubes;
+	data_start += 4;
+
+	*((double *) data_start) = zspdata.cube_size;
+	data_start += 8;
+
+	*((double *) data_start) = zspdata.cube_radius;
+	data_start += 8;
+
+	ZSP_Data * zdata = (ZSP_Data *)(&zspdata);
+
+	for (LIF<ZSP_zone> znl(&zdata->zone_array); !znl.done(); znl.next())
+	{
+		*((int *) data_start) = znl().num_z_polys;
+		data_start += 4;
+
+		*((int *) data_start) = znl().num_z_verts;
+		data_start += 4;
+
+		int i;
+		for (i=0; i<znl().num_z_polys; i++)
+		{
+			*((int *) data_start) = znl().z_poly_list[i];
+			data_start += 4;
+		}
+
+		for (i=0; i<znl().num_z_verts; i++)
+		{
+			*((int *) data_start) = znl().z_vert_list[i];
+			data_start += 4;
+		}
+	}
+}	
-- 
cgit v1.3