# The following is a shar archive. Extract using 'sh filename' not 'csh'.
# The rest of this file will extract:
# dist/poly2obj.README include/topology.h src/cmds/make.poly2obj src/cmds/mkdefs.IRIS_3000 src/cmds/mkdefs.I_3000_DEBUG src/cmds/mkdefs.IRIS_4D src/cmds/mkdefs.I_4D_DEBUG src/cmds/mkdefs.SUN src/cmds/mkdefs.SUN_DEBUG src/cmds/poly2obj.c src/obj_lib/alloc_
obj.c src/obj_lib/app_obj.c src/obj_lib/rd_poly.c src/obj_lib/wt_obj.c man/man1/poly2obj.sl man/man1/Make.poly2obj man/man3/alloc_obj.sl man/man3/app_obj.sl man/man3/rd_poly.sl man/man3/wt_obj.sl man/man3/Make.poly2obj man/man5/objects.sl man/man5/poly.ma
n man/man5/Make.poly2obj
echo extracting dist/poly2obj.README
echo mkdir ./dist
mkdir ./dist
sed 's/^X//' > dist/poly2obj.README << '!EOR!' 
X
X
X
X	poly2obj - a program written in C to convert objects of the form
X		used by Andrew Hume's catalogue of polyhedra to the ASCII
X		object description form used by Wavefront Technologies'
X		CAD, animation and rendering package.
X
X		Author: Stewart Dickson
X                        celia!tpg!dickson@tis.llnl.gov
X
!EOR!
echo extracting include/topology.h
echo mkdir ./include
mkdir ./include
sed 's/^X//' > include/topology.h << '!EOR!' 
X/* file: topology.h
X
X   description: Data structure for linking topological aspects of a 3-D
X		graphical object.  Objects are described via the ASCII
X		object description language as being composed of vertices
X		and topological elements of several types with material
X		attributes.  This system provides sufficient information
X		for determining the complete geometry, topology and material 
X		properties of the object.  This data structure provides the 
X		framework for a complete linkage of these object attributes.
X
X		Additionally is supported the recursive definition of
X		'graphical meta-elements' which enable the efficient 
X		specification of object hierarchical morphology (detail).
X
X   author: Stewart Dickson
X*/
X
X/* define a 32-bit Magic Number for portability */
X#define SPD_MAGIC 0xff5500aa
X
X/* define values of object-to-polygon mapping directives */
X#define MAP 1
X#define NOMAP 0
X
X/* define several types of parametric surfaces */
X#define BSPLINE 0
X#define BEZIER 1
X#define CARDINAL 2
X
Xstruct sizes {
X	char notraces;
X	char noshados;
X	char nocalls;
X	char nolibs;
X	char nomaps;
X	char valence;
X	char nosgrps;
X	short nolverts;
X	short nofverts;
X	short nopverts;
X	short nogroups;
X	int nolines;
X	int nofaces;
X	int nopoints;
X	int noverts;
X	int notverts;
X	int noedges;
X	int nomtls;
X	int nocircs;
X	int nosphrs;
X	int noptchs;
X	int nogverts;
X	int nogfaces;
X	int nogpoints;
X	int noglines;
X	int nogsphrs;
X	int nogcircs;
X	int nogptchs;
X	int nomdefs;
X	int nomrefs;
X	int nomops;
X
X	char objname[128];
X	};
X
Xstruct topology {
X
X	struct sizes size;
X
X	struct sizes alloc;
X
X	struct bounding_box {
X		float minx;
X		float maxx;
X		float miny;
X		float maxy;
X		float minz;
X		float maxz;
X		} b_box;
X
X	struct tracobj {
X		char objname[128];
X		} **trace_obj;
X
X	struct shadobj {
X		char objname[128];
X		} **shad_obj;
X
X	struct caldfile {
X		char filnam[128];
X		} **call;
X
X	struct library {
X		char libnam[128];
X		} **lib;
X
X	struct material {
X		char mtlnam[128];
X		int illum;
X		struct RGB {
X			float red, green, blue;
X			} Ka, Kd, Ks, Ni, Tf;
X		float Ns, dissolve;
X		float mass_dens, surf_elast, surf_stiff;
X		float damping, visc_drag, visc_damp;
X		} **mtl;
X
X	struct mapping {
X		char mapnam[128];
X		} **map;
X
X	struct objgrps {
X		int noverts;
X		int nopoints;
X		int nolines;
X		int nofaces;
X		int nocircs;
X		int nosphrs;
X		int noptchs;
X
X		char grpnam[128];
X
X		int *vertno;
X		int *pointno;
X		int *lineno;
X		int *faceno;
X		int *circno;
X		int *sphrno;
X		int *ptchno;
X		} **group;
X
X	struct vertex {
X		char facec;
X		char edgec;
X		short group;
X		int mtl;
X		float x;
X		float y;
X		float z;
X		struct Vector_struct {
X			float x;
X			float y;
X			float z;
X			} normal;
X		int *faceno;
X		int *edgeno;
X		} **vertex;
X
X	struct faces {
X		char bevel;
X		char mapflg;
X		short map;
X		short smooth;
X		short group;
X		short vertc;
X		short edgec;
X		int mtl;
X		int *vertno;
X		int *tvertno;
X		int *edgeno;
X		struct Vector_struct normal;
X		} **face;
X
X	struct textur {
X		float u;
X		float v;
X		float w;
X		} **texver;
X
X	struct lines {
X		short vertc;
X		short group;
X		int mtl;
X		int *vertno;
X		} **line;
X
X	struct edges {
X		int vertno[2];
X		int faceno[2];
X		float length;
X		float theta;
X		} **edge;
X
X	struct points {
X		short vertc;
X		short group;
X		int *vertno;
X		} **point;
X
X	struct circles {
X		short group;
X		short res;
X		int vertno;
X		float beg_ang;
X		float end_ang;
X		float rad;
X		struct Vector_struct x, y;
X		} **circl;
X
X	struct spheres {
X		short map;
X		short smooth;
X		short group;
X		short res;
X		int vertno;
X		int mtl;
X		float rad;
X		} **spher;
X
X	struct bicubes {
X		char type;
X		char u_res;
X		char v_res;
X		short map;
X		short smooth;
X		short group;
X		int mtl;
X		int vertno[4][4];
X		int tvertno[4][4];
X		} **bicub;
X
X	struct topology **metadef;
X
X	struct meta_reference {
X		float orient[4][4][4];
X		struct topology *meta;
X		} **metaref;
X
X	struct meta_oper {
X		char opname[128];
X		struct topology *(*function)();
X		struct param_iface *objarg;
X		} **metaop;
X
X	};
!EOR!
echo extracting src/cmds/make.poly2obj
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/make.poly2obj << '!EOR!' 
X# file: makefile
X#
X#   contents: compilation instructions for the Stewart Dickson 3-D Graphical
X#	     modelling package.
X#
X#   author: Stewart Dickson
X#
X
X
X# ******* Build for various machines *******
X#include mkdefs.IRIS_3000
X#include mkdefs.I_3000_DEBUG
X#include mkdefs.IRIS_4D
X#include mkdefs.I_4D_DEBUG
X#include mkdefs.SUN
Xinclude mkdefs.SUN_DEBUG
X
XWAVE_INCL=   $(WF_DIR)/include
X
XWAVE_LIB=    $(WF_DIR)/lib
X
XSRC_DIR=     $(SPD_DIR)/src
X
XINCL_DIR=    $(SPD_DIR)/include
X
X#BIN=         $(SPD_DIR)/bin
X
XBIN=         /usr/local/tools
X
XCMD_DIR=     $(SRC_DIR)/cmds
X
XOBJ_SRC=     $(SRC_DIR)/obj_lib
X
XSCMP_SRC=     $(SRC_DIR)/scmp_lib
X
XIMF_SRC=     $(SRC_DIR)/imf_lib
X
XUTIL_SRC=     $(SRC_DIR)/util_lib
X
X#
X# commands
X#
XALL: poly2obj 
X
Xclean:
X	rm -f *.o $(OBJ_SRC)/*.o $(SCMP_SRC)/*.o $(IMF_SRC)/*.o \
X		$(UTIL_SRC)/*.o
X
X#
X
Xpoly2obj: $(BIN)/poly2obj
X$(BIN)/poly2obj: poly2obj.o alloc_obj.o app_obj.o rd_poly.o wt_obj.o \
X		$(INCL_DIR)/topology.h
X	$(LD) poly2obj.o $(OBJ_SRC)/alloc_obj.o $(OBJ_SRC)/app_obj.o \
X		$(OBJ_SRC)/rd_poly.o $(OBJ_SRC)/wt_obj.o \
X		-o $(BIN)/poly2obj $(LDFLAGS); chmod 755 $@
X
Xpoly2obj.o: poly2obj.c $(INCL_DIR)/topology.h 
X	$(CC) $(CFLAGS) -I$(INCL_DIR) poly2obj.c
X
X#
X# graphical utility functions
X#
X
Xalloc_obj.o: $(OBJ_SRC)/alloc_obj.o
X$(OBJ_SRC)/alloc_obj.o: $(OBJ_SRC)/alloc_obj.c $(INCL_DIR)/topology.h
X	$(CC) $(CFLAGS) -I$(INCL_DIR) $(OBJ_SRC)/alloc_obj.c; \
X		 mv alloc_obj.o $(OBJ_SRC)
X
Xapp_obj.o: $(OBJ_SRC)/app_obj.o
X$(OBJ_SRC)/app_obj.o: $(OBJ_SRC)/app_obj.c $(INCL_DIR)/topology.h
X	$(CC) $(CFLAGS) -I$(INCL_DIR) $(OBJ_SRC)/app_obj.c ; \
X		mv app_obj.o $(OBJ_SRC)
X
Xrd_poly.o: $(OBJ_SRC)/rd_poly.o
X$(OBJ_SRC)/rd_poly.o: $(OBJ_SRC)/rd_poly.c $(INCL_DIR)/topology.h
X	$(CC) $(CFLAGS) -I$(INCL_DIR) $(OBJ_SRC)/rd_poly.c ; \
X		mv rd_poly.o $(OBJ_SRC)
X
X
Xwt_obj.o: $(OBJ_SRC)/wt_obj.o
X$(OBJ_SRC)/wt_obj.o: $(OBJ_SRC)/wt_obj.c $(INCL_DIR)/topology.h
X	$(CC) $(CFLAGS) -I$(INCL_DIR) $(OBJ_SRC)/wt_obj.c ; \
X		mv wt_obj.o $(OBJ_SRC)
X
!EOR!
echo extracting src/cmds/mkdefs.IRIS_3000
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/mkdefs.IRIS_3000 << '!EOR!' 
X# ******  Build for IRIS 3000  ******
X
XCFLAGS= -O -DIRIS -DWAVE
X# non-Wavefront make
X# CFLAGS= -O -DIRIS
X
XLDFLAGS= -Zf -Zg -lbsd -lm
X
!EOR!
echo extracting src/cmds/mkdefs.I_3000_DEBUG
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/mkdefs.I_3000_DEBUG << '!EOR!' 
X# ******  Build for IRIS 3000, debug using dbx ******
X
XCC= cc -c
X
XCFLAGS= -g -DIRIS -DWAVE
X# non-Wavefront make
X# CFLAGS= -g -DIRIS
X
XLD= cc --x
X
XLDFLAGS= -Zf -Zg -lbsd -lm
X
!EOR!
echo extracting src/cmds/mkdefs.IRIS_4D
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/mkdefs.IRIS_4D << '!EOR!' 
X# ******  Build for IRIS 4D  ******
X
XCFLAGS= -G 0 -Olimit 850 -DIRIS -DWAVE
X# non-Wavefront make
X# CFLAGS= -G 0 -Olimit 850 -DIRIS
X
XLDFLAGS= -G 0 -lbsd -lm
X
!EOR!
echo extracting src/cmds/mkdefs.I_4D_DEBUG
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/mkdefs.I_4D_DEBUG << '!EOR!' 
X# ****** Build for IRIS 4D, debug using dbx ******
XCC= cc -c -g2
X
XCFLAGS= -G 0 -DWAVE
X# non-Wavefront make
X# CFLAGS= -G 0
X
XLD= cc -g2
X
XLDFLAGS= -G 0 -lbsd -lm
X
!EOR!
echo extracting src/cmds/mkdefs.SUN
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/mkdefs.SUN << '!EOR!' 
X# ******  Build for Sun  *******
X
XCC= cc -c
X
XCFLAGS= -O -DSUN -DWAVE
X# non-Wavefront make
X# CFLAGS= -O -DSUN
X
XLD= cc
X
XLDFLAGS= -s -ffpa -lm
X
X
!EOR!
echo extracting src/cmds/mkdefs.SUN_DEBUG
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/mkdefs.SUN_DEBUG << '!EOR!' 
X# ******  Build for Sun, Debug using DBX ******
XCC= cc -c
X
X# *** debug make ****
X#CFLAGS= -v -g -DSUN -DWAVE -ffpa
X
XCFLAGS= -g -DSUN -DWAVE -ffpa
X# non-Wavefront make
X# CFLAGS= -g -DSUN -ffpa
X
X# *** debug make ****
X#LD= cc -v -g
X
XLD= cc -g
X
XLDFLAGS= -lg -lm
X
!EOR!
echo extracting src/cmds/poly2obj.c
echo mkdir ./src
mkdir ./src
echo mkdir ./src/cmds
mkdir ./src/cmds
sed 's/^X//' > src/cmds/poly2obj.c << '!EOR!' 
X/* file: poly2obj.c
X
X   description:  C source code for a program to convert files from
X                 Andrew Hume's catalogue of 142 regular polyhedra to
X                 the Wavefront Technologies ASCII object description
X                 format.
X
X   author: Stewart Dickson
X*/
X
X#include <stdio.h>
X#include <topology.h>
X
Xint verbflg = 0;
X
Xmain(argc,argv)
Xint argc;
Xchar **argv;
X{
XFILE *in_file;
Xstruct topology *polyhedron = NULL, *rd_poly();
Xint argindx = 1;
Xchar file_name[128];
X
Xfile_name[0] = '\0';
X
Xwhile(argindx < argc) { /* parse command line arguments if any */
X    if(!strncmp(argv[argindx],"-h",2)) { /* help */
X        fprintf(stderr,"usage: poly2obj [options] [file_name]\n");
X        fprintf(stderr,"options:\n");
X        fprintf(stderr,"\t-h[elp]    - this message\n");
X        fprintf(stderr,"\t-v [level] - verbose\n");
X        exit(0);
X        }
X    else if(!strcmp(argv[argindx],"-v")) { /* verbose */
X        if(++argindx < argc) {
X            if((verbflg = atoi(argv[argindx])) < 1) { /* non-numeric */
X                verbflg = 1;
X                }
X            else {
X                argindx++;
X                }
X            }
X        }
X    else if(argindx < argc - 1) { /* option not found (not file name) */
X        fprintf(stderr,"poly2obj: option '%s' not found\n",argv[argindx]);
X        fprintf(stderr,"usage: poly2obj [options] [file_name]\n");
X        fprintf(stderr,"options:\n");
X        fprintf(stderr,"\t-h[elp]    - this message\n");
X        fprintf(stderr,"\t-v [level] - verbose\n");
X        exit(-1);
X        }
X    else { /* we have not matched an option -- argindx == argc - 1
X              - must be a file name */
X        strcpy(file_name, argv[argc - 1]);
X        argindx++;
X        }
X    }
X
Xif(strlen(file_name) > 0) { /* if a file name has been read from command line */
X    if((in_file = fopen(file_name,"r")) == NULL) {
X        fprintf(stderr,"poly2obj: cannot open file '%s'\n",file_name);
X        exit(-1);
X        }
X    }
Xelse { /* take input from stdin */
X    in_file = stdin;
X    }
X
Xpolyhedron = rd_poly(polyhedron,in_file);
X
Xwt_obj(stdout,polyhedron);
X}
!EOR!
echo extracting src/obj_lib/alloc_obj.c
echo mkdir ./src
mkdir ./src
echo mkdir ./src/obj_lib
mkdir ./src/obj_lib
sed 's/^X//' > src/obj_lib/alloc_obj.c << '!EOR!' 
X/* file alloc_obj.c
X
X   description: C modules for allocating storage for geometrical/topological
X        object description structures.
X
X   contents: alloc_obj()
X         def_parms()
X         copy_alc()
X         copy_siz()
X         realc_obj()
X         free_obj()
X
X   author: Stewart Dickson
X*/
X
X#include <stdio.h>
X#include <topology.h>
X
X/*  function: alloc_obj
X
X    description: allocates storage for a geometrical object description
X         structure.
X
X    parameters: alcalc - pointer to structure containing allocation size
X                parameters.
X
X    returns:    alcobj - pointer to structure allocated for object description.
X
X   author: Stewart Dickson
X*/
X
Xunsigned cumsize;
X
Xstruct topology *alloc_obj(alcalc)
Xstruct sizes *alcalc;
X{
Xextern int verbflg;
Xstruct sizes *def_parms();
Xstruct topology *alcobj,*alloc_hdr(),*alloc_verts(),*alloc_tverts();
Xstruct topology *alloc_faces(),*alloc_lines(),*alloc_edges(),*alloc_circs();
Xstruct topology *alloc_points(),*alloc_sphrs(),*alloc_ptchs(),*alloc_mdefs();
Xstruct topology *alloc_mrefs(),*alloc_moprs();
Xunsigned objsize;
Xchar *malloc();
X
X/* struct sizes should have requested size parameters for object */
X
Xif(alcalc==NULL) { /* if not, check for environment variables set */
X    alcalc=def_parms(alcalc);
X    }
X
X/* allocate object structure and header info */
Xalcobj = alloc_hdr(alcalc);
X
X/* allocate vertex structures */
Xalcobj = alloc_verts(alcobj,alcalc);
X
X/* allocate face structures */
Xalcobj = alloc_faces(alcobj,alcalc);
X
X/* allocate texture vertex structures */
Xalcobj = alloc_tverts(alcobj,alcalc);
X
X/* allocate line structures */
Xalcobj = alloc_lines(alcobj,alcalc);
X
X/* allocate edge structures */
Xalcobj = alloc_edges(alcobj,alcalc);
X
X/* allocate point structures */
Xalcobj = alloc_points(alcobj,alcalc);
X
X/* allocate circle structures */
Xalcobj = alloc_circs(alcobj,alcalc);
X
X/* allocate sphere structures */
Xalcobj = alloc_sphrs(alcobj,alcalc);
X
X/* allocate bicubic patch structures */
Xalcobj = alloc_ptchs(alcobj,alcalc);
X
X/* allocate object meta-element definitions */
Xalcobj = alloc_mdefs(alcobj,alcalc);
X
X/* allocate object meta-element references */
Xalcobj = alloc_mrefs(alcobj,alcalc);
X
X/* allocate object meta-element operations */
Xalcobj = alloc_moprs(alcobj,alcalc);
X
Xif(verbflg>0) {
X    fprintf(stderr,"alloc_obj: object size %u : done\n",cumsize);
X    }
X
Xreturn(alcobj);
X}
X
X
X
X
X
X
X/* function: alloc_hdr
X
X   description: allocates storage for an object and its header information.
X*/
X
X
Xstruct topology *alloc_hdr(hdralc)
Xstruct sizes *hdralc;
X{
Xstruct topology *hdrobj;
Xunsigned objsize;
Xint tracindx,shadindx,calindx,mtlindx,mapindx,libindx,gindx;
X
Xif(hdralc == NULL) {
X    fprintf(stderr,
X        "alloc_hdr: ERROR - NULL allocation parameter struct received\n");
X    exit(-1);
X    }
X
X/* make sure we are allocating at least one of everything */
Xif(hdralc->nomtls<=0) hdralc->nomtls=1;
Xif(hdralc->nomaps<=0) hdralc->nomaps=1;
Xif(hdralc->nocalls<=0) hdralc->nocalls=1;
Xif(hdralc->notraces<=0) hdralc->notraces=1;
Xif(hdralc->noshados<=0) hdralc->noshados=1;
Xif(hdralc->nolibs<=0) hdralc->nolibs=1;
Xif(hdralc->nogroups<=0) hdralc->nogroups=1;
Xif(hdralc->nogverts<=0) hdralc->nogverts=1;
Xif(hdralc->noglines<=0) hdralc->noglines=1;
Xif(hdralc->nogfaces<=0) hdralc->nogfaces=1;
Xif(hdralc->nogcircs<=0) hdralc->nogcircs=1;
Xif(hdralc->nogsphrs<=0) hdralc->nogsphrs=1;
Xif(hdralc->nogptchs<=0) hdralc->nogptchs=1;
Xif(hdralc->nogpoints<=0) hdralc->nogpoints=1;
X
X/* allocate space for object structure */
Xif((hdrobj=(struct topology *)malloc(sizeof(struct topology)))==NULL) {
X    fprintf(stderr,"alloc_hdr: cannot allocate object structure size %d\n",
X            sizeof(struct topology));
X    exit(-1);
X    }
X
Xcumsize=sizeof(struct topology);
X
X/* set object name */
Xstrcpy(hdrobj->size.objname,hdralc->objname);
Xstrcpy(hdrobj->alloc.objname,hdralc->objname);
X
Xif(verbflg>0) {
X    fprintf(stderr,"alloc_hdr: object '%s'\n",hdrobj->size.objname);
X    }
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: hdrobj = 0x%x, size %d\n",
X        hdrobj,
X        sizeof(struct topology));
X    }
X
X/* allocate space for 'trace_obj' structure pointers */
Xobjsize=hdralc->notraces*sizeof(struct tracobj *);
Xif((hdrobj->trace_obj=(struct tracobj **)malloc(objsize))==NULL) {
X    fprintf(stderr,
X        "alloc_hdr: cannot allocate 'hdrobj->trace_obj' size %u\n",
X        objsize);
X    exit(-1);
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d traced objects\n",hdralc->notraces);
X    fprintf(stderr,"alloc_hdr: hdrobj->trace_obj = 0x%x, size = %d\n",
X        hdrobj->trace_obj,objsize);
X    }
X/* allocate space for 'trace_obj' structures */
Xobjsize=sizeof(struct tracobj);
Xfor(tracindx=0;tracindx<hdralc->notraces;tracindx++) {
X    if((hdrobj->trace_obj[tracindx] =
X            (struct tracobj *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->trace_obj[%d]'",
X            tracindx);
X        fprintf(stderr,
X            " size %u\n", objsize);
X        exit(-1);
X        }
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_hdr: hdrobj->trace_obj[%d] = 0x%x, size = %d\n",
X            tracindx,hdrobj->trace_obj[tracindx],objsize);
X        }
X    cumsize+=objsize;
X    }
X/* initialize 'trace_obj' string to a default */
Xstrcpy(hdrobj->trace_obj[0]->objname,"# no objects traced");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->trace_obj[0]->objname);
X    }
X
X/* allocate space for 'shad_obj' structure pointers */
Xobjsize=hdralc->noshados*sizeof(struct shadobj *);
Xif((hdrobj->shad_obj=(struct shadobj **)malloc(objsize))==NULL) {
X    fprintf(stderr,
X        "alloc_hdr: cannot allocate 'hdrobj->shad_obj' size %u\n",
X        objsize);
X    exit(-1);
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d shadowed objects\n",hdralc->noshados);
X    fprintf(stderr,"alloc_hdr: hdrobj->shad_obj = 0x%x, size = %d\n",
X        hdrobj->shad_obj,objsize);
X    }
X/* allocate space for 'shad_obj' structures */
Xobjsize=sizeof(struct shadobj);
Xfor(shadindx=0;shadindx<hdralc->noshados;shadindx++) {
X    if((hdrobj->shad_obj[shadindx] =
X            (struct shadobj *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->shad_obj[%d]'",
X            shadindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit(-1);
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: hdrobj->shad_obj[%d] = 0x%x,",
X            shadindx, hdrobj->shad_obj[shadindx]);
X        fprintf(stderr," size = %d\n",objsize);
X        }
X    }
X/* initialize 'shad_obj' string to a default */
Xstrcpy(hdrobj->shad_obj[0]->objname,"# no objects shadowed");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->shad_obj[0]->objname);
X    }
X
X/* allocate space for 'call' structure pointers */
Xobjsize=hdralc->nocalls*sizeof(struct caldfile *);
Xif((hdrobj->call=(struct caldfile **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_hdr: cannot allocate 'hdrobj->call' size %u\n",
X        objsize);
X    exit(-1);
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d file calls\n",hdralc->nocalls);
X    fprintf(stderr,"alloc_hdr: hdrobj->call = 0x%x, size = %d\n",
X        hdrobj->call,objsize);
X    }
X/* allocate space for 'call' structures */
Xobjsize=sizeof(struct caldfile);
Xfor(calindx=0;calindx<hdralc->nocalls;calindx++) {
X    if((hdrobj->call[calindx]=(struct caldfile *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->call[%d]'",
X            calindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit(-1);
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_hdr: hdrobj->call[%d] = 0x%x, size = %d\n",
X            calindx,hdrobj->call[calindx],objsize);
X        }
X    }
X/* initialize 'call' string to a default */
Xstrcpy(hdrobj->call[0]->filnam,"# no files called");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->call[0]->filnam);
X    }
X
X/* allocate space for 'lib' structure pointers */
Xobjsize=hdralc->nolibs*sizeof(struct library *);
Xif((hdrobj->lib=(struct library **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_hdr: cannot allocate 'hdrobj->lib' size %u\n",
X        objsize);
X    exit(-1);
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d libraries\n",hdralc->nolibs);
X    fprintf(stderr,"alloc_hdr: hdrobj->lib = 0x%x, size = %d\n",
X        hdrobj->lib,objsize);
X    }
X/* allocate space for 'lib' structures */
Xobjsize=sizeof(struct library);
Xfor(libindx=0;libindx<hdralc->nolibs;libindx++) {
X    if((hdrobj->lib[libindx]=(struct library *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->lib[%d]'",
X            libindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit(-1);
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: hdrobj->lib[%d] = 0x%x, size = %d\n",
X            libindx,hdrobj->lib[libindx],objsize);
X        }
X    }
X/* initialize 'lib' string to a default */
Xstrcpy(hdrobj->lib[0]->libnam,"# no libraries used");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->lib[0]->libnam);
X    }
X
X/* allocate space for 'mtl' structure pointers */
Xobjsize = hdralc->nomtls*sizeof(struct material *);
Xif((hdrobj->mtl = (struct material **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_hdr: cannot allocate 'hdrobj->mtl' size %u\n",
X        objsize);
X    exit(-1);
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d materials\n",hdralc->nomtls);
X    fprintf(stderr,"alloc_hdr: hdrobj->mtl = 0x%x, size = %d\n",
X        hdrobj->mtl,objsize);
X    }
X/* allocate space for 'mtl' structures */
Xobjsize = sizeof(struct material);
Xfor(mtlindx=0; mtlindx<hdralc->nomtls; mtlindx++) {
X    if((hdrobj->mtl[mtlindx] = (struct material *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->mtl[%d]'",
X            mtlindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit(-1);
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_hdr: hdrobj->mtl[%d] = 0x%x, size = %d\n",
X            mtlindx,hdrobj->mtl[mtlindx],objsize);
X        }
X    /* initialize material attributes to defaults */
X    hdrobj->mtl[mtlindx]->Ka.red = 0.1;
X    hdrobj->mtl[mtlindx]->Ka.green = 0.1;
X    hdrobj->mtl[mtlindx]->Ka.blue = 0.1;
X    hdrobj->mtl[mtlindx]->Kd.red = 1.0;
X    hdrobj->mtl[mtlindx]->Kd.green = 1.0;
X    hdrobj->mtl[mtlindx]->Kd.blue = 1.0;
X    hdrobj->mtl[mtlindx]->Ks.red = 0.5;
X    hdrobj->mtl[mtlindx]->Ks.green = 0.5;
X    hdrobj->mtl[mtlindx]->Ks.blue = 0.5;
X    hdrobj->mtl[mtlindx]->Ni.red = 1.25;
X    hdrobj->mtl[mtlindx]->Ni.green = 1.375;
X    hdrobj->mtl[mtlindx]->Ni.blue = 1.5;
X    hdrobj->mtl[mtlindx]->Tf.red = 1.0;
X    hdrobj->mtl[mtlindx]->Tf.green = 1.0;
X    hdrobj->mtl[mtlindx]->Tf.blue = 1.0;
X    hdrobj->mtl[mtlindx]->Ns = 100;
X    hdrobj->mtl[mtlindx]->mass_dens = 0.0;
X    hdrobj->mtl[mtlindx]->surf_elast = 0.0;
X    hdrobj->mtl[mtlindx]->surf_stiff = 0.0;
X    }
X/* initialize 'mtl' string to a default */
Xstrcpy(hdrobj->mtl[0]->mtlnam,"# no materials used");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->mtl[0]->mtlnam);
X    }
X
X/* allocate space for 'map' structure pointers */
Xobjsize=(unsigned)hdralc->nomaps*sizeof(struct mapping *);
Xif((hdrobj->map = (struct mapping **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_hdr: cannot allocate 'hdrobj->map' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d texture maps\n",hdralc->nomaps);
X    fprintf(stderr,"alloc_hdr: hdrobj->map = 0x%x, size = %d\n",
X        hdrobj->map,objsize);
X    }
X/* allocate space for 'map' structures */
Xobjsize=sizeof(struct mapping);
Xfor(mapindx=0;mapindx<hdralc->nomaps;mapindx++) {
X    if((hdrobj->map[mapindx]=(struct mapping *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->map[%d]'",
X            mapindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_hdr: hdrobj->map[%d] = 0x%x, size = %d\n",
X            mapindx,hdrobj->map[mapindx],objsize);
X        }
X    }
X/* initialize 'map' string to a default */
Xstrcpy(hdrobj->map[0]->mapnam,"# no mappings used");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->map[0]->mapnam);
X    }
X
X/* allocate space for pointers to 'group' structures */
Xobjsize=(unsigned)hdralc->nogroups*sizeof(struct objgrps *);
Xif((hdrobj->group=(struct objgrps **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_hdr: cannot allocate 'hdrobj->group' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %d groups\n",hdralc->nogroups);
X    fprintf(stderr,"alloc_hdr: hdrobj->group = 0x%x, size = %d\n",
X        hdrobj->group,objsize);
X    }
X
X/* allocate space for 'group->*' arrays */
Xfor(gindx=0;gindx<hdralc->nogroups;gindx++) {
X    objsize=sizeof(struct objgrps);
X    if((hdrobj->group[gindx]=(struct objgrps *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]'",
X            gindx);
X        fprintf(stderr," size %u\n",objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d] ",gindx);
X        fprintf(stderr,"= 0x%lx\n", hdrobj->group[gindx]);
X        }
X    objsize=hdralc->nogverts*sizeof(int);
X    if((hdrobj->group[gindx]->vertno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->vertno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->vertno ",gindx);
X        fprintf(stderr,"= 0x%lx, size %u\n",
X                    hdrobj->group[gindx]->vertno,objsize);
X        }
X    objsize=hdralc->nogpoints*sizeof(int);
X    if((hdrobj->group[gindx]->pointno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->pointno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->pointno ",gindx);
X        fprintf(stderr,"= 0x%lx, size %u\n",
X                    hdrobj->group[gindx]->pointno,objsize);
X        }
X    objsize=hdralc->noglines*sizeof(int);
X    if((hdrobj->group[gindx]->lineno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->lineno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->lineno ",gindx);
X        fprintf(stderr,"= 0x%lx\n", hdrobj->group[gindx]->lineno);
X        }
X    objsize=hdralc->nogfaces*sizeof(int);
X    if((hdrobj->group[gindx]->faceno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->faceno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->faceno ",gindx);
X        fprintf(stderr,"= 0x%lx\n", hdrobj->group[gindx]->faceno);
X        }
X    objsize=hdralc->nogcircs*sizeof(int);
X    if((hdrobj->group[gindx]->circno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->circno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->circno ",gindx);
X        fprintf(stderr,"= 0x%lx\n", hdrobj->group[gindx]->circno);
X        }
X    objsize=hdralc->nogsphrs*sizeof(int);
X    if((hdrobj->group[gindx]->sphrno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->sphrno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->sphrno ",gindx);
X        fprintf(stderr,"= 0x%lx\n", hdrobj->group[gindx]->sphrno);
X        }
X    objsize=hdralc->nogptchs*sizeof(int);
X    if((hdrobj->group[gindx]->ptchno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_hdr: cannot allocate 'hdrobj->group[%d]",
X            gindx);
X        fprintf(stderr,"->ptchno' size %u\n",
X            objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,"alloc_hdr: group[%d]->ptchno ",gindx);
X        fprintf(stderr,"= 0x%lx\n", hdrobj->group[gindx]->ptchno);
X        }
X    /* initialize group element pointer counts to 0 */
X    hdrobj->group[gindx]->noverts=0;
X    hdrobj->group[gindx]->nofaces=0;
X    hdrobj->group[gindx]->nolines=0;
X    hdrobj->group[gindx]->nopoints=0;
X    hdrobj->group[gindx]->nocircs=0;
X    hdrobj->group[gindx]->nosphrs=0;
X    hdrobj->group[gindx]->noptchs=0;
X    }
X
X/* initialize 'group' name to a default */
Xstrcpy(hdrobj->group[0]->grpnam,"d");
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_hdr: %s\n",hdrobj->group[0]->grpnam);
X    }
X
X/* initialize structure pointers to NULL, indicating no allocation */
Xhdrobj->vertex = NULL;
Xhdrobj->texver = NULL;
Xhdrobj->face = NULL;
Xhdrobj->edge = NULL;
Xhdrobj->line = NULL;
Xhdrobj->point = NULL;
Xhdrobj->circl = NULL;
Xhdrobj->spher = NULL;
Xhdrobj->bicub = NULL;
Xhdrobj->metadef = NULL;
X
X/* initialize allocation sizes in output object */
Xhdrobj->alloc.nomtls=hdralc->nomtls;
Xhdrobj->alloc.nomaps=hdralc->nomaps;
Xhdrobj->alloc.notraces=hdralc->notraces;
Xhdrobj->alloc.noshados=hdralc->noshados;
Xhdrobj->alloc.nocalls=hdralc->nocalls;
Xhdrobj->alloc.nolibs=hdralc->nolibs;
Xhdrobj->alloc.nogroups=hdralc->nogroups;
Xhdrobj->alloc.nogverts=hdralc->nogverts;
Xhdrobj->alloc.noglines=hdralc->noglines;
Xhdrobj->alloc.nogfaces=hdralc->nogfaces;
Xhdrobj->alloc.nogcircs=hdralc->nogcircs;
Xhdrobj->alloc.nogsphrs=hdralc->nogsphrs;
Xhdrobj->alloc.nogptchs=hdralc->nogptchs;
Xhdrobj->alloc.nogpoints=hdralc->nogpoints;
X
X/* initialize population size parameters in output object */
Xhdrobj->size.nomtls=1;
Xhdrobj->size.nomaps=1;
Xhdrobj->size.notraces=1;
Xhdrobj->size.noshados=1;
Xhdrobj->size.nocalls=1;
Xhdrobj->size.nolibs=1;
Xhdrobj->size.nogroups=1;
Xfor(gindx=0;gindx<hdrobj->alloc.nogroups;gindx++) {
X    hdrobj->group[gindx]->noverts = 0;
X    hdrobj->group[gindx]->nolines = 0;
X    hdrobj->group[gindx]->nofaces = 0;
X    hdrobj->group[gindx]->nopoints = 0;
X    hdrobj->group[gindx]->nocircs = 0;
X    hdrobj->group[gindx]->nosphrs = 0;
X    hdrobj->group[gindx]->noptchs = 0;
X    }
Xhdrobj->size.nogverts=0;
Xhdrobj->size.noglines=0;
Xhdrobj->size.nogfaces=0;
Xhdrobj->size.nogcircs=0;
Xhdrobj->size.nogsphrs=0;
Xhdrobj->size.nogptchs=0;
Xhdrobj->size.nogpoints=0;
X
Xreturn(hdrobj);
X}
X
X
X
X
X
X
X
X/* function: alloc_verts
X
X   description: allocates space for vertices in an object
X*/
X
X
Xstruct topology *alloc_verts(vertobj,vertalc)
Xstruct topology *vertobj;
Xstruct sizes *vertalc;
X{
Xunsigned objsize;
Xint vindx;
X
Xif(verbflg > 10) {
X    fprintf(stderr,"entering alloc_verts\n");
X    }
X
X/* make sure we are allocating at least one vertex */
Xif(vertalc->noverts<=0) vertalc->noverts=1;
Xif(vertalc->valence<=0) vertalc->valence=1;
X
X/* allocate space for 'vertex' structure pointers */
Xobjsize=vertalc->noverts*sizeof(struct vertex *);
Xif((vertobj->vertex=(struct vertex **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_verts: cannot allocate 'vertobj->vertex' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_verts: %d vertices\n",vertalc->noverts);
X    fprintf(stderr,"alloc_verts: vertobj->vertex = 0x%x, size = %d\n",
X        vertobj->vertex,objsize);
X    }
X
X/* allocate space for 'vertex[]' structures, 'vertex->faceno'
X    and 'vertex->edgeno' arrays */
Xfor(vindx=0;vindx<vertalc->noverts;vindx++) {
X    objsize=sizeof(struct vertex);
X    if((vertobj->vertex[vindx]=(struct vertex *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_verts: cannot allocate 'vertobj->vertex[%d]'",
X            vindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit(-1);
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_verts: vertobj->vertex[%d] = 0x%x, size = %d\n",
X            vindx,vertobj->vertex[vindx],objsize);
X        }
X    objsize=vertalc->valence*sizeof(int);
X    if((vertobj->vertex[vindx]->faceno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr, "alloc_verts: cannot allocate");
X        fprintf(stderr," 'vertobj->vertex[%d]->faceno' size %u\n",
X            vindx,objsize);
X        exit(-1);
X        }
X    if((vertobj->vertex[vindx]->edgeno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr, "alloc_verts: cannot allocate");
X        fprintf(stderr," 'vertobj->vertex[%d]->edgeno' size %u\n",
X            vindx,objsize);
X        exit(-1);
X        }
X
X    /* initialize vertex attributes */
X    vertobj->vertex[vindx]->normal.x = 0;
X    vertobj->vertex[vindx]->normal.y = 0;
X    vertobj->vertex[vindx]->normal.z = 0;
X    vertobj->vertex[vindx]->group = 0;
X    vertobj->vertex[vindx]->mtl = 0;
X
X    cumsize+=objsize*2;
X    }
X
X/* update allocation size parameters in output object */
Xvertobj->alloc.noverts=vertalc->noverts;
Xvertobj->alloc.valence=vertalc->valence;
X
X/* update population size parameters in output object */
Xvertobj->size.noverts=1;
Xvertobj->size.valence=0;
X
Xreturn(vertobj);
X}
X
X
X
X
X
X/* function: alloc_faces
X
X   description: allocates face structures for an object.
X*/
X
X
Xstruct topology *alloc_faces(facobj,facalc)
Xstruct topology *facobj;
Xstruct sizes *facalc;
X{
Xunsigned objsize;
Xint findx;
X
X/* make sure we allocate at least one of each entity */
Xif(facalc->nofaces<=0) facalc->nofaces=1;
X/* make sure we allocate at least three vertices per face */
Xif(facalc->nofverts<3) facalc->nofverts=3;
X
X/* allocate space for 'face' structure pointers */
Xobjsize=facalc->nofaces*sizeof(struct faces *);
Xif((facobj->face=(struct faces **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_faces: cannot allocate 'facobj->face' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_faces: %d faces\n",facalc->nofaces);
X    fprintf(stderr,"alloc_faces: facobj->face = 0x%x, size = %d\n",
X        facobj->face,objsize);
X    }
X
X/* allocate space for 'face[]' structures, 'face->vertno', 'face->tvertno'
X   and 'face->edgeno' arrays */
Xfor(findx=0;findx<facalc->nofaces;findx++) {
X    objsize=sizeof(struct faces);
X    if((facobj->face[findx]=(struct faces *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_faces: cannot allocate 'facobj->face[%d]'",
X            findx);
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_faces: facobj->face[%d] = 0x%x, size = %d\n",
X            findx,facobj->face[findx],objsize);
X        }
X    objsize=facalc->nofverts*sizeof(int);
X    if((facobj->face[findx]->vertno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_faces: cannot allocate");
X        fprintf(stderr," 'facobj->face[%d]->vertno' size %u\n",
X            findx,objsize);
X        exit();
X        }
X    if((facobj->face[findx]->tvertno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_faces: cannot allocate");
X        fprintf(stderr," 'facobj->face[%d]->tvertno' size %u\n",
X            findx,objsize);
X        exit();
X        }
X    if((facobj->face[findx]->edgeno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_faces: cannot allocate");
X        fprintf(stderr," 'facobj->face[%d]->edgeno' size %u\n",
X            findx,objsize);
X        exit();
X        }
X    cumsize+=objsize*3;
X    }
X
X/* update allocation sizes in output object */
Xfacobj->alloc.nofaces=facalc->nofaces;
Xfacobj->alloc.nofverts=facalc->nofverts;
X
X/* initialize population sizes in output object */
Xfacobj->size.nofaces=0;
Xfacobj->size.nofverts=0;
X
Xreturn(facobj);
X}
X
X
X
X
X
X/* function: alloc_tverts
X
X   description: allocates texture vertices for an object.
X*/
X
X
Xstruct topology *alloc_tverts(tvrtobj,tvrtalc)
Xstruct topology *tvrtobj;
Xstruct sizes *tvrtalc;
X{
Xunsigned objsize;
Xint tvindx;
X
X/* make sure we allocate at least one */
Xif(tvrtalc->notverts<=0) tvrtalc->notverts=1;
X
X/* allocate space for 'texver' structure pointers */
Xobjsize=tvrtalc->notverts*sizeof(struct textur *);
Xif((tvrtobj->texver=(struct textur **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_tverts: cannot allocate");
X    fprintf(stderr," 'tvrtobj->texver' size %u\n",objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_tverts: %d texture vertices\n",tvrtalc->notverts);
X    fprintf(stderr,"alloc_tverts: tvrtobj->texver = 0x%x, size = %d\n",
X        tvrtobj->texver,objsize);
X    }
X
X/* allocate space for 'texver' structures */
Xobjsize=sizeof(struct textur);
Xfor(tvindx=0;tvindx<tvrtalc->notverts;tvindx++) {
X    if((tvrtobj->texver[tvindx]=(struct textur *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_tverts: cannot allocate");
X        fprintf(stderr,
X            " 'tvrtobj->texver[%d]' size %u\n",tvindx,objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_tverts: tvrtobj->texver[%d] = 0x%x, size = %d\n",
X            tvindx,tvrtobj->texver[tvindx],objsize);
X        }
X    }
X
X/* update allocation sizes in output object */
Xtvrtobj->alloc.notverts=tvrtalc->notverts;
X
X/* initialize population sizes in output object */
Xtvrtobj->size.notverts=1;
X
Xreturn(tvrtobj);
X}
X
X
X
X
X
X/* function: alloc_lines
X
X   description: allocates lines for an object.
X*/
X
X
Xstruct topology *alloc_lines(linobj,linalc)
Xstruct topology *linobj;
Xstruct sizes *linalc;
X{
Xunsigned objsize;
Xint lindx;
X
X/* make sure we allocate at least one */
Xif(linalc->nolverts<=0) linalc->nolverts=1;
Xif(linalc->nolines<=0) linalc->nolines=1;
X
X/* allocate space for 'line' structure pointers */
Xobjsize=linalc->nolines*sizeof(struct lines *);
Xif((linobj->line=(struct lines **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_lines: cannot allocate 'linobj->line' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_lines: %d lines, %d verts/line\n",
X        linalc->nolines,linalc->nolverts);
X    fprintf(stderr,"alloc_lines: linobj->line = 0x%x, size = %d\n",
X        linobj->line,objsize);
X    }
X
X/* allocate space for 'line->vertno' arrays */
Xfor(lindx=0;lindx<linalc->nolines;lindx++) {
X    objsize=sizeof(struct lines);
X    if((linobj->line[lindx]=(struct lines *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_lines: cannot allocate 'linobj->line[%d]'",
X            lindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_lines: linobj->line[%d] = 0x%x, size = %d\n",
X            lindx,linobj->line[lindx],objsize);
X        }
X    objsize=linalc->nolverts*sizeof(int);
X    if((linobj->line[lindx]->vertno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_lines: cannot allocate");
X        fprintf(stderr," 'linobj->line[%d]->vertno' size %u\n",
X            lindx,objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    }
X
X/* update allocation sizes in output object */
Xlinobj->alloc.nolverts=linalc->nolverts;
Xlinobj->alloc.nolines=linalc->nolines;
X
X/* initialize population sizes in output object */
Xlinobj->size.nolverts=0;
Xlinobj->size.nolines=0;
X
Xreturn(linobj);
X}
X
X
X
X
X
X/* function: alloc_edges
X
X   description: allocates edges for an object.
X*/
X
X
Xstruct topology *alloc_edges(edgobj,edgalc)
Xstruct topology *edgobj;
Xstruct sizes *edgalc;
X{
Xunsigned objsize;
Xint eindx;
X
X/* make sure we allocate at least one */
Xif(edgalc->noedges <= 0) edgalc->noedges = 1;
X
X/* allocate space for 'edge' structure pointers */
Xobjsize=edgalc->noedges*sizeof(struct edges *);
Xif((edgobj->edge=(struct edges **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_edges: cannot allocate 'edgobj->edge' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_edges: %d edges\n",edgalc->noedges);
X    fprintf(stderr,"alloc_edges: edgobj->edge = 0x%x, size = %d\n",
X        edgobj->edge,objsize);
X    }
X/* allocate space for 'edge' structures */
Xobjsize=sizeof(struct edges);
Xfor(eindx=0;eindx<edgalc->noedges;eindx++) {
X    if((edgobj->edge[eindx]=(struct edges *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_edges: cannot allocate 'edgobj->edge[%d]'",
X            eindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    cumsize+=objsize;
X
X    /* initialize edge face indices to recognized undefined values */
X    edgobj->edge[eindx]->faceno[0] = -1;
X    edgobj->edge[eindx]->faceno[1] = -1;
X
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_edges: edgobj->edge[%d] = 0x%x, size = %d\n",
X            eindx,edgobj->edge[eindx],objsize);
X        }
X    }
X
X/* update allocation sizes in output object */
Xedgobj->alloc.noedges = edgalc->noedges;
X
X/* initialize population sizes in output object */
Xedgobj->size.noedges = 0;
X
Xreturn(edgobj);
X}
X
X
X
X
X
X/* function: alloc_points
X
X   description: allocates points for an object
X*/
X
X
Xstruct topology *alloc_points(pntobj,pontalc)
Xstruct topology *pntobj;
Xstruct sizes *pontalc;
X{
Xunsigned objsize;
Xint pindx;
X
X/* make sure we allocate at least one */
Xif(pontalc->nopverts<=0) pontalc->nopverts=1;
Xif(pontalc->nopoints<=0) pontalc->nopoints=1;
X
X/* allocate space for 'point' structure pointers */
Xobjsize=pontalc->nopoints*sizeof(struct points *);
Xif((pntobj->point=(struct points **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_points: cannot allocate 'pntobj->point' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_points: %d points\n",pontalc->nopoints);
X    fprintf(stderr,"alloc_points: pntobj->point = 0x%x, size = %d\n",
X        pntobj->point,objsize);
X    }
X
X/* allocate space for 'point' structures and 'point->vertno' arrays */
Xfor(pindx=0;pindx<pontalc->nopoints;pindx++) {
X    objsize=sizeof(struct points);
X    if((pntobj->point[pindx]=(struct points *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_points: cannot allocate 'pntobj->point[%d]'",
X            pindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_points: pntobj->point[%d] = 0x%x, size = %d\n",
X            pindx,pntobj->point[pindx],objsize);
X        }
X    objsize=pontalc->nopverts*sizeof(int);
X    if((pntobj->point[pindx]->vertno=(int *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_points: cannot allocate");
X        fprintf(stderr," 'pntobj->point[%d]->vertno' size %u\n",
X            pindx,objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    }
X
X
X/* update allocation sizes in output object */
Xpntobj->alloc.nopverts=pontalc->nopverts;
Xpntobj->alloc.nopoints=pontalc->nopoints;
X
X/* initialize population sizes in output object */
Xpntobj->size.nopverts=0;
Xpntobj->size.nopoints=0;
X
Xreturn(pntobj);
X}
X
X
X
X
X
X/* function: alloc_circs(circobj,circalc)
X
X   description: allocates circles for an object.
X*/
X
X
Xstruct topology *alloc_circs(circobj,circalc)
Xstruct topology *circobj;
Xstruct sizes *circalc;
X{
Xunsigned objsize;
Xint cindx;
X
X/* make sure we allocate at least one */
Xif(circalc->nocircs<=0) circalc->nocircs=1;
X
X/* allocate space for 'circl' structure pointers */
Xobjsize=circalc->nocircs*sizeof(struct circles *);
Xif((circobj->circl=(struct circles **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_circs: cannot allocate");
X    fprintf(stderr," 'circobj->circl' size %u\n",objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_circs: %d circles\n",circalc->nocircs);
X    fprintf(stderr,"alloc_circs: circobj->circl = 0x%x, size = %d\n",
X        circobj->circl,objsize);
X    }
X/* allocate space for 'circl' structures */
Xobjsize=sizeof(struct circles);
Xfor(cindx=0;cindx<circalc->nocircs;cindx++) {
X    if((circobj->circl[cindx]=(struct circles *)malloc(objsize))==NULL) {
X        fprintf(stderr,"alloc_circs: cannot allocate");
X        fprintf(stderr,
X            " 'circobj->circl[%d]' size %u\n",cindx,objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_circs: circobj->circl[%d] = 0x%x, size = %d\n",
X            cindx,circobj->circl[cindx],objsize);
X        }
X    }
X
X/* update allocation sizes in output object */
Xcircobj->alloc.nocircs=circalc->nocircs;
X
X/* initialize population sizes in output object */
Xcircobj->size.nocircs=0;
X
Xreturn(circobj);
X}
X
X
X
X
X
X/* function: alloc_sphrs()
X
X   description: allocates spheres for an object.
X*/
X
X
Xstruct topology *alloc_sphrs(sphobj,sphalc)
Xstruct topology *sphobj;
Xstruct sizes *sphalc;
X{
Xunsigned objsize;
Xint sindx;
X
X/* make sure we allocate at least one */
Xif(sphalc->nosphrs<=0) sphalc->nosphrs = 1;
X
X/* allocate space for 'spher' structure pointers */
Xobjsize=sphalc->nosphrs*sizeof(struct spheres *);
Xif((sphobj->spher=(struct spheres **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_sphrs: cannot allocate 'sphobj->spher' size %u\n",
X        objsize);
X    exit();
X    }
Xcumsize+=objsize;
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_sphrs: %d spheres\n",sphalc->nosphrs);
X    fprintf(stderr,"alloc_sphrs: sphobj->spher = 0x%x, size = %d\n",
X        sphobj->spher,objsize);
X    }
X/* allocate space for 'spher' structures */
Xobjsize=sizeof(struct spheres);
Xfor(sindx=0;sindx<sphalc->nosphrs;sindx++) {
X    if((sphobj->spher[sindx]=(struct spheres *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_sphrs: cannot allocate 'sphobj->spher[%d]'",
X            sindx);
X        fprintf(stderr," size %u\n",objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_sphrs: sphobj->spher[%d] = 0x%x, size = %d\n",
X            sindx,sphobj->spher[sindx],objsize);
X        }
X    }
X
X/* update allocation sizes in output object */
Xsphobj->alloc.nosphrs=sphalc->nosphrs;
X
X/*initialize population sizes in output object */
Xsphobj->size.nosphrs = 0;
X
Xreturn(sphobj);
X}
X
X
X
X
X
X/* function: alloc_ptchs
X
X   description: allocates bicubic patches for an object 
X*/
X
X
Xstruct topology *alloc_ptchs(ptchobj,ptchalc)
Xstruct topology *ptchobj;
Xstruct sizes *ptchalc;
X{
Xunsigned objsize;
Xint bindx;
X
X/* make sure allocation sizes in object struct are non-zero */
Xif(ptchalc->noptchs<=0) ptchalc->noptchs=1;
X
X/* allocate space for 'bicub' structure pointers */
Xobjsize=ptchalc->noptchs*sizeof(struct bicubes *);
Xcumsize+=objsize;
Xif((ptchobj->bicub=(struct bicubes **)malloc(objsize))==NULL) {
X    fprintf(stderr,"alloc_ptchs: cannot allocate 'ptchobj->bicub' size %u\n",
X        objsize);
X    exit();
X    }
Xif(verbflg>10) {
X    fprintf(stderr,"alloc_ptchs: %d bicubic patches\n",ptchalc->noptchs);
X    fprintf(stderr,"alloc_ptchs: ptchobj->bicub = 0x%x, size = %d\n",
X        ptchobj->bicub,objsize);
X    }
X/* allocate space for 'bicub' structures */
Xobjsize=sizeof(struct bicubes);
Xfor(bindx=0;bindx<ptchalc->noptchs;bindx++) {
X    if((ptchobj->bicub[bindx]=(struct bicubes *)malloc(objsize))==NULL) {
X        fprintf(stderr,
X            "alloc_ptchs: cannot allocate 'ptchobj->bicub[%d]'",
X            bindx);
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    cumsize+=objsize;
X    if(verbflg>20) {
X        fprintf(stderr,
X            "alloc_ptchs: ptchobj->bicub[%d] = 0x%x, size = %d\n",
X            bindx,ptchobj->bicub[bindx],objsize);
X        }
X    }
X
X/* set allocation sizes in object struct */
Xptchobj->alloc.noptchs=ptchalc->noptchs;
X
X/* initialize object sizes in object struct */
Xptchobj->size.noptchs=0;
X
Xreturn(ptchobj);
X}
X
X
X
X
X
X/* function: alloc_mdefs
X
X   description: allocates object meta-element definitions for an object
X*/
X
X
Xstruct topology *alloc_mdefs(mdefobj,mdefalc)
Xstruct topology *mdefobj;
Xstruct sizes *mdefalc;
X{
X
Xreturn(mdefobj);
X}
X
X
X
X
X
X/* function: alloc_mrefs
X
X   description: allocates object meta-element references for an object
X*/
X
X
Xstruct topology *alloc_mrefs(mrefobj,mrefalc)
Xstruct topology *mrefobj;
Xstruct sizes *mrefalc;
X{
X
Xreturn(mrefobj);
X}
X
X
X
X
X
X/* function: alloc_moprs
X
X   description: allocates object meta-element operations for an object
X*/
X
X
Xstruct topology *alloc_moprs(moprobj,mopralc)
Xstruct topology *moprobj;
Xstruct sizes *mopralc;
X{
X
Xreturn(moprobj);
X}
X
X
X
X
X
X/* function: def_parms
X
X   description: reads environment for object size parameter variables or
X        uses internal defaults for object allocation parameters.
X
X   author: Stewart Dickson
X*/
X
X
X
Xstruct sizes *def_parms(defalc)
Xstruct sizes *defalc;
X{
Xchar  *getenv(),*c_vert,*c_tvert,*c_nomtl,*c_novpe,*c_notex,*c_nolib;
Xchar *c_nolines,*c_nopoints,*c_nofaces,*c_nocircs,*c_nosphrs;
Xchar *c_noptchs,*c_noedges,*c_novpl,*c_novpf,*c_valence;
X
Xif(verbflg>0) {
X    fprintf(stderr,"entering def_parms()\n");
X    }
X
Xif(defalc==NULL) {
X    /* allocate space for object size parameter structure */
X    if((defalc=(struct sizes *)malloc(sizeof(struct sizes)))==NULL) {
X        fprintf(stderr,
X            "def_parms: cannot allocate 'defalc' struct size %d\n",
X                sizeof(struct sizes));
X        exit();
X        }
X    }
X
X/* check for Wavefront environment variables then SPD variables */
X
X/* check environment */
Xif((c_vert=getenv("WF_MVRT"))==NULL) { /* if not set, use default */
X    defalc->noverts=5000;
X    defalc->nolines=100;
X    defalc->nopoints=100;
X    defalc->nofaces=5000;
X    defalc->noedges=100;
X    defalc->nocircs=100;
X    defalc->nosphrs=100;
X    defalc->noptchs=10;
X    defalc->noglines=100;
X    defalc->nogverts=5000;
X    defalc->nogpoints=100;
X    defalc->nogfaces=5000;
X    defalc->nogcircs=100;
X    defalc->nogsphrs=100;
X    defalc->nogptchs=10;
X    }
Xelse {
X    fprintf(stderr,"WF_MVRT = %s\n",c_vert);
X    defalc->noverts=atoi(c_vert);
X    defalc->nolines=100;
X    defalc->nopoints=100;
X    defalc->nofaces=5000;
X    defalc->noedges=100;
X    defalc->nocircs=100;
X    defalc->nosphrs=100;
X    defalc->noptchs=10;
X    defalc->noglines=100;
X    defalc->nogverts=100;
X    defalc->nogpoints=100;
X    defalc->nogfaces=5000;
X    defalc->nogcircs=100;
X    defalc->nogsphrs=100;
X    defalc->nogptchs=10;
X    }
X
Xif((c_tvert=getenv("WF_MTVS"))==NULL) { /* if not set, use default */
X    defalc->notverts=5000;
X    }
Xelse {
X    fprintf(stderr,"WF_MTVS = %s\n",c_tvert);
X    defalc->notverts=atoi(c_tvert);
X    }
X
Xif((c_nomtl=getenv("WF_MMTL"))==NULL) { /* if not set, use default */
X    defalc->nomtls=100;
X    }
Xelse {
X    fprintf(stderr,"WF_MMTL = %s\n",c_nomtl);
X    defalc->nomtls=atoi(c_nomtl);
X    }
X
Xif((c_novpe=getenv("WF_MVPE"))==NULL) { /* if not set, use default */
X    defalc->nolverts=500;
X    defalc->nofverts=10;
X    defalc->valence=10;
X    defalc->nopverts=500;
X    }
Xelse {
X    fprintf(stderr,"WF_MVPE = %s\n",c_novpe);
X    defalc->nolverts=atoi(c_novpe);
X    if((defalc->nofverts=atoi(c_novpe)/10)<3) {
X        defalc->nofverts=4;
X        }
X    defalc->nopverts=atoi(c_novpe);
X    if((defalc->valence=atoi(c_novpe)/20)<3) {
X        defalc->valence=6;
X        }
X    }
X
Xif((c_notex=getenv("WF_MTEX"))==NULL) { /* if not set, use default */
X    defalc->nomaps=10;
X    defalc->nocalls=10;
X    defalc->nolibs=10;
X    }
Xelse {
X    fprintf(stderr,"WF_MTEX = %s\n",c_notex);
X    defalc->nomaps=atoi(c_notex);
X    defalc->nocalls=atoi(c_notex);
X    defalc->nolibs=atoi(c_notex);
X    }
X
Xdefalc->notraces=1;
Xdefalc->noshados=1;
Xdefalc->nogroups=10;
X
X/* check for SPD environment variables */
X
Xif((c_vert=getenv("SPD_VERTS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_VERTS = %s\n",c_vert);
X    defalc->noverts=atoi(c_vert);
X    }
X
Xif((c_vert=getenv("SPD_GROUPS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_GROUPS = %s\n",c_vert);
X    defalc->nogroups=atoi(c_vert);
X    }
X
Xif((c_tvert=getenv("SPD_TVERTS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_TVERTS = %s\n",c_tvert);
X    defalc->notverts=atoi(c_tvert);
X    }
X
Xif((c_nomtl=getenv("SPD_MTLS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_MTLS = %s\n",c_nomtl);
X    defalc->nomtls=atoi(c_nomtl);
X    }
X
Xif((c_notex=getenv("SPD_TEX"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_TEX = %s\n",c_notex);
X    defalc->nomaps=atoi(c_notex);
X    }
X
Xif((c_nolib=getenv("SPD_LIBS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_LIBS = %s\n",c_nolib);
X    defalc->nolibs=atoi(c_nolib);
X    defalc->nocalls=atoi(c_nolib);
X    }
X
Xif((c_nolines=getenv("SPD_LINES"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_LINES = %s\n",c_nolines);
X    defalc->nolines=atoi(c_nolines);
X    defalc->noglines=atoi(c_nolines);
X    }
X
Xif((c_nopoints=getenv("SPD_POINTS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_POINTS = %s\n",c_nopoints);
X    defalc->nopoints=atoi(c_nopoints);
X    defalc->nogpoints=atoi(c_nopoints);
X    }