/******************************************************************************\
  Copyright 1995 The University of North Carolina at Chapel Hill.
  All Rights Reserved.

  Permission to use, copy, modify and distribute this software and its
  documentation for educational, research and non-profit purposes, without
  fee, and without a written agreement is hereby granted, provided that the
  above copyright notice and the following three paragraphs appear in all
  copies.

  IN NO EVENT SHALL THE UNIVERSITY OF NORTH CAROLINA
  AT CHAPEL HILL BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
  INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING
  OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
  UNIVERSITY OF NORTH CAROLINA HAS BEEN ADVISED OF THE POSSIBILITY OF
  SUCH DAMAGES.

  THE UNIVERSITY OF NORTH CAROLINA SPECIFICALLY DISCLAIM ANY WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HERUNDER IS
  ON AN "AS IS" BASIS, AND THE UNIVERSITY OF NORTH CAROLINA HAS NO OBLIGATIONS
  TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

  The author may be contacted via:

  US Mail:             Mike Goslin
                       Department of Computer Science
                       Sitterson Hall, CB #3175
                       University of N. Carolina
                       Chapel Hill, NC 27599-3175

  Phone:               (919)962-1719

  EMail:               goslin@cs.unc.edu

*******************************************************************************/
/*******************************************************************************
*
* FILENAME:     bead.C 
* CLASS:        Bead 
* DESCRIPTION:  
* AUTHOR:       Mike Goslin
* CREATED:      2/7/95
* REVISIONS:
*
*******************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <iostream.h>
#include <time.h>
#include <math.h>

#include "bead.H"

/*******************************************************************************
*     Function: printComment
*  Description: prints out an mgComment structure 
*        Input:  
*       Output:
*******************************************************************************/
void printComment(const mgComment& comment)
{
    printf("\n");
    printf("==============================================================\n");
    printf(" COMMENT\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", comment.length);
    printf("%s\n", comment.text);
}

/*******************************************************************************
*     Function: Constructor
*        Class: HeaderBead
*       Access: Public
*  Description: Default constructor - initializes to reasonable values
*        Input:  
*       Output:
*******************************************************************************/
HeaderBead::HeaderBead(void)
{
    time_t	the_time;

    type = MG_HEADER;
    strcpy(name, "HEADER");

    fltHeader.opcode = MG_HEADER;
    fltHeader.length = FLT14_HEADER_RECORD_LENGTH;
    fltHeader.frev = 14;
    fltHeader.dbrev = 1;
    the_time = time(NULL);
    strcpy(fltHeader.revDate, ctime(&the_time)); // we want these to always be
					      // identical for binary file diffs
    fltHeader.nextGroupId = 0;
    fltHeader.nextLodId = 0;
    fltHeader.nextObjId = 0;
    fltHeader.nextPolyId = 0;
    fltHeader.unitMulDiv = 1;
    fltHeader.unitType = 0;   // defaults to METERS
    fltHeader.texWhite = 0; // defaults to FALSE on new textured polygons base
    fltHeader.flags = 1;      // save vertex normals = first bit
    // SWLat, SWLong, NELat, NELong, latOrig, longOrig no longer used in 14.1
    fltHeader.projType = 0; // defaults to "flat earth"
    // oswIfmt[2], otorTrans[2], upperLat, lowerLat, nlHash not used in 14.1
    fltHeader.nextDofId = 0;
    fltHeader.vtxFormat = 1;  // defaults to double precision float
    fltHeader.dblOrig = 100;  // OpenFlight
    fltHeader.swIfmt[0] = 0;
    fltHeader.swIfmt[1] = 0;
    fltHeader.terTrans[0] = 0;
    fltHeader.terTrans[1] = 0;
    fltHeader.soundId = 0;
    fltHeader.pathId = 0;
    fltHeader.clipId = 0;
    fltHeader.textId = 0;
    fltHeader.switchId = 0;
    // Initialize these to reasonable values - update them as the database is
    // read in
    fltHeader.SWLat1 = 0;
    fltHeader.SWLong1 = 0;
    fltHeader.NELat1 = 0;
    fltHeader.NELong1 = 0;
    fltHeader.latOrig1 = 0;
    fltHeader.longOrig1 = 0;
    fltHeader.upperLat1 = 0;
    fltHeader.lowerLat1 = 0;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: HeaderBead
*       Access: Public
*  Description:
*        Input: A valid flight header structure
*       Output:
*******************************************************************************/
HeaderBead::HeaderBead(const mgHeader& _fltHeader)
{
    type = MG_HEADER;
    strcpy(name, DEFAULT_NAME);

    if (_fltHeader.frev < 14)
    {
	fprintf(stderr, "WARNING: Old flight version <%d>.  Converting header to version 14.\n", _fltHeader.frev);
	memcpy(&fltHeader, &_fltHeader, FLT13_HEADER_RECORD_LENGTH);
	fltHeader.frev = 14;
	fltHeader.soundId = 0;
	fltHeader.pathId = 0;
	fltHeader.clipId = 0;
	fltHeader.textId = 0;
	fltHeader.switchId = 0;
	fltHeader.SWLat1 = (double)_fltHeader.SWLat;
	fltHeader.SWLong1 = (double)_fltHeader.SWLong;
	fltHeader.NELat1 = (double)_fltHeader.NELat;
	fltHeader.NELong1 = (double)_fltHeader.NELong;
	fltHeader.latOrig1 = (double)_fltHeader.latOrig;
	fltHeader.longOrig1 = (double)_fltHeader.longOrig;
	fltHeader.upperLat1 = (double)_fltHeader.upperLat;
	fltHeader.lowerLat1 = (double)_fltHeader.lowerLat;
	fltHeader.length = FLT14_HEADER_RECORD_LENGTH;
    }
    else	
    	fltHeader = _fltHeader;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Destructor
*        Class: HeaderBead
*       Access: Public
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
HeaderBead::~HeaderBead()
{
}

/*******************************************************************************
*     Function: printHeader
*  Description:
*        Input:
*       Output:
*******************************************************************************/
void printHeader(const mgHeader& fltHeader)
{
    char projtype[20];

    printf("\n");
    printf("==============================================================\n");
    printf(" HEADER RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", fltHeader.length);
    printf("Format Revision:\t\t\t%d\n", fltHeader.frev);
    printf("Revision level:\t\t\t\t%d\n", fltHeader.dbrev);
    printf("Last revision:\t\t\t\t%s\n", fltHeader.revDate);
    printf("Next group:\t\t\t\t%d\n", fltHeader.nextGroupId);
    printf("Next lod:\t\t\t\t%d\n", fltHeader.nextLodId);
    printf("Next object:\t\t\t\t%d\n", fltHeader.nextObjId);
    printf("Next polygon:\t\t\t\t%d\n", fltHeader.nextPolyId);
    printf("Unit multiplier:\t\t\t%d\n", fltHeader.unitMulDiv);
    printf("Units:\t\t\t\t\t%d\n", fltHeader.unitType);
    if (fltHeader.texWhite == 1)  
	printf("\ttexwhite is TRUE\n");
    printf("Flags:\t\t\t\t\t%d\n", fltHeader.flags);
    if (fltHeader.flags & 1)
       printf("\tSave Vertex Normals\n");
    switch(fltHeader.projType) {
	case 0: strcpy(projtype, "Flat Earth"); break; 
	case 1: strcpy(projtype, "Trapezoidal"); break; 
	case 2: strcpy(projtype, "Round Earth"); break; 
	case 3: strcpy(projtype, "Lambert"); break; 
	case 4: strcpy(projtype, "UTM"); break; 
	case 5: strcpy(projtype, "Geodetic"); break; 
	case 6: strcpy(projtype, "Geocentric"); break; 
	default: strcpy(projtype, "Unknown"); break; }
    printf("Projection type:\t\t\t%s\n", projtype);
    printf("Next dof:\t\t\t\t%d\n", fltHeader.nextDofId); 
    if (fltHeader.vtxFormat == 1) 
    	printf("Flag:\tDbl precision float vertex:\tTRUE\n");
    printf("Database origin:\t\t\t%d\n", fltHeader.dblOrig);
    printf("Southwest database coordinate x:\t%.4f\n", fltHeader.swIfmt[0]);
    printf("Southwest database coordinate y:\t%.4f\n", fltHeader.swIfmt[1]);
    printf("Delta x to place database:\t\t%.4f\n", fltHeader.terTrans[0]);
    printf("Delta y to place database:\t\t%.4f\n", fltHeader.terTrans[1]);
    printf("Next sound bead id:\t\t\t%d\n", fltHeader.soundId);
    printf("Next path bead id:\t\t\t%d\n", fltHeader.pathId);
    printf("Next clipping region id:\t\t%d\n", fltHeader.clipId);
    printf("Next text bead id:\t\t\t%d\n", fltHeader.textId);
    printf("Next switch bead id:\t\t\t%d\n", fltHeader.switchId);
    printf("Southwest database corner latitude :\t%.4f\n", fltHeader.SWLat1);
    printf("Southwest database corner longitude:\t%.4f\n", fltHeader.SWLong1);
    printf("Northeast database corner latitude :\t%.4f\n", fltHeader.NELat1);
    printf("Northeast database corner longitude:\t%.4f\n", fltHeader.NELong1);
    printf("Database origin latitude:\t\t%.4f\n", fltHeader.latOrig1);
    printf("Database orign longitude:\t\t%.4f\n", fltHeader.longOrig1);
    printf("Lambert upper latitude:\t\t\t%.4f\n", fltHeader.upperLat1);
    printf("Lambert lower latitude:\t\t\t%.4f\n", fltHeader.lowerLat1);
}

/*******************************************************************************
*     Function: print
*        Class: HeaderBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
void HeaderBead::print(void) const
{
    printHeader(fltHeader);
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexRecordBead
*       Access: Public
*  Description: Default constructor 
*        Input:
*       Output:
*******************************************************************************/
VertexRecordBead::VertexRecordBead(void)
{
    fltVert = NULL;
    offset = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexRecordBead
*       Access: Public
*  Description: Default constructor - initializes a vertex with an
*		mgVertSharedAbs structure and type
*        Input: double coord[3] = x, y, z
*       Output:
*******************************************************************************/
VertexRecordBead::VertexRecordBead(double coord[3])
{
    type = MG_DVERT_ABS;
    strcpy(name, DEFAULT_NAME);

    fltVert = (mgVertSharedAbs *)malloc(sizeof(mgVertSharedAbs));
    ((mgVertSharedAbs *)fltVert)->opcode = MG_DVERT_ABS;
    ((mgVertSharedAbs *)fltVert)->length = FLT_VERT_SHARED_ABS_LENGTH;
    ((mgVertSharedAbs *)fltVert)->vcolor = -1; // Defaults to unshaded
    ((mgVertSharedAbs *)fltVert)->flags = 0; // Hard edge flag
    type = MG_DVERT_ABS;
    VEC3COPY(((mgVertSharedAbs *)fltVert)->p, coord);
    offset = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexRecordBead
*       Access: Public
*  Description: Default constructor - initializes a vertex with an
*		mgVertSharedNorm structure and type
*        Input: double coord[3] = x, y, z, float norm[3] = x, y, z
*       Output:
*******************************************************************************/
VertexRecordBead::VertexRecordBead(double coord[3], float norm[3])
{
    type = MG_DVERT_NORM;
    strcpy(name, DEFAULT_NAME);

    fltVert = (mgVertSharedNorm *)malloc(sizeof(mgVertSharedNorm));
    ((mgVertSharedNorm *)fltVert)->opcode = MG_DVERT_NORM;
    ((mgVertSharedNorm *)fltVert)->length = FLT_VERT_SHARED_NORM_LENGTH;
    ((mgVertSharedNorm *)fltVert)->vcolor = 4102;
    ((mgVertSharedNorm *)fltVert)->flags = 0; // Hard edge flag
    type = MG_DVERT_NORM;
    VEC3COPY(((mgVertSharedNorm *)fltVert)->p, coord);
    VEC3COPY(((mgVertSharedNorm *)fltVert)->n, norm);
    offset = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexRecordBead
*       Access: Public
*  Description: Default constructor - initializes a vertex with an
*		mgVertSharedNorm structure and type
*        Input: double coord[3] = x, y, z, float norm[3] = x, y, z
*       Output:
*******************************************************************************/
VertexRecordBead::VertexRecordBead(double coord[3], float u, float v)
{
    type = MG_DVERT_ABS_TEX;
    strcpy(name, DEFAULT_NAME);

    fltVert = (mgVertSharedAbsTex *)malloc(sizeof(mgVertSharedAbsTex));
    ((mgVertSharedAbsTex *)fltVert)->opcode = MG_DVERT_ABS_TEX;
    ((mgVertSharedAbsTex *)fltVert)->length = FLT_VERT_SHARED_ABS_TEX_LENGTH;
    ((mgVertSharedAbsTex *)fltVert)->vcolor = -1; // Defaults to unshaded
    ((mgVertSharedAbsTex *)fltVert)->flags = 0; // Hard edge flag
    type = MG_DVERT_ABS_TEX;
    VEC3COPY(((mgVertSharedNormTex *)fltVert)->p, coord);
    ((mgVertSharedNormTex *)fltVert)->t[0] = u;
    ((mgVertSharedNormTex *)fltVert)->t[1] = v;
    offset = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexRecordBead
*       Access: Public
*  Description: Default constructor - initializes a vertex with an
*		mgVertSharedNorm structure and type
*        Input: double coord[3] = x, y, z, float norm[3] = x, y, z
*       Output:
*******************************************************************************/
VertexRecordBead::VertexRecordBead(double coord[3], float norm[3], float tex[2])
{
    type = MG_DVERT_NORM_TEX;
    strcpy(name, DEFAULT_NAME);

    fltVert = (mgVertSharedNormTex *)malloc(sizeof(mgVertSharedNormTex));
    ((mgVertSharedNormTex *)fltVert)->opcode = MG_DVERT_NORM_TEX;
    ((mgVertSharedNormTex *)fltVert)->length = FLT_VERT_SHARED_NORM_TEX_LENGTH;
    ((mgVertSharedNormTex *)fltVert)->vcolor = -1; // Defaults to unshaded
    ((mgVertSharedNormTex *)fltVert)->flags = 0; // Hard edge flag
    type = MG_DVERT_NORM_TEX;
    VEC3COPY(((mgVertSharedNormTex *)fltVert)->p, coord);
    VEC3COPY(((mgVertSharedNormTex *)fltVert)->n, norm);
    VEC2COPY(((mgVertSharedNormTex *)fltVert)->t, tex);
    offset = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexRecordBead
*       Access: Public
*  Description:
*        Input: A valid flight vertex type and structure
*       Output:
*******************************************************************************/
VertexRecordBead::VertexRecordBead(ushort _type, void *_fltVert)
{
    type = _type;
    strcpy(name, DEFAULT_NAME);
    fltVert = _fltVert;
    offset = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Destructor
*        Class: VertexRecordBead
*       Access: Public
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
VertexRecordBead::~VertexRecordBead()
{
    free(fltVert);
}

/*******************************************************************************
*     Function: getPoint 
*        Class: VertexRecordBead
*       Access: Public
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
void VertexRecordBead::getPoint(double point[3]) const
{
    switch (type)
    {
	case MG_DVERT_ABS:
	    VEC3COPY(point, ((mgVertSharedAbs *)fltVert)->p);
	    break;
	case MG_DVERT_NORM:
	    VEC3COPY(point, ((mgVertSharedNorm *)fltVert)->p);
	    break;
	case MG_DVERT_NORM_TEX:
	    VEC3COPY(point, ((mgVertSharedNormTex *)fltVert)->p);
	    break;
	case MG_DVERT_ABS_TEX:
	    VEC3COPY(point, ((mgVertSharedAbsTex *)fltVert)->p);
	    break;
    }
}

/*******************************************************************************
*     Function: getNormal 
*        Class: VertexRecordBead
*       Access: Public
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
uint VertexRecordBead::getNormal(float norm[3]) const
{
    if (type == MG_DVERT_NORM)
    {
	VEC3COPY(norm, ((mgVertSharedNorm *)fltVert)->n);
    }
    else if (type == MG_DVERT_NORM_TEX)
    {
	VEC3COPY(norm, ((mgVertSharedNormTex *)fltVert)->n);
    }
    else return 0;
    return 1;
}

/*******************************************************************************
*     Function: getUV 
*        Class: VertexRecordBead
*       Access: Public
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
uint VertexRecordBead::getUV(float uv[2]) const
{
    if (type == MG_DVERT_ABS_TEX)
    {
	VEC2COPY(uv, ((mgVertSharedAbsTex *)fltVert)->t);
    }
    else if (type == MG_DVERT_NORM_TEX)
    {
	VEC2COPY(uv, ((mgVertSharedNormTex *)fltVert)->t);
    }
    else return 0;
    return 1;
}

/*******************************************************************************
*     Function: printVertexRecord
*  Description:
*        Input:
*       Output:
*******************************************************************************/
void printVertexRecord(ushort type, void *fltVert)
{
    switch (type)
    {
	case MG_DVERT_ABS:
    printf("\n");
    printf("==============================================================\n");
    printf(" SHADED VERTEX RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", ((mgVertSharedAbs *)fltVert)->length);
    printf("x:\t\t\t\t%.3f\n", ((mgVertSharedAbs *)fltVert)->p[0]);
    printf("y:\t\t\t\t%.3f\n", ((mgVertSharedAbs *)fltVert)->p[1]);
    printf("z:\t\t\t\t%.3f\n", ((mgVertSharedAbs *)fltVert)->p[2]);
    printf("Hard Edge Flag:\t\t\t%d\n", ((mgVertSharedAbs *)fltVert)->flags 
								& 0x0001);
    printf("Touch Flag:\t\t\t%d\n", ((mgVertSharedAbs *)fltVert)->flags & 
								0x0002);
    printf("Vertex Color:\t\t\t%d\n", ((mgVertSharedAbs *)fltVert)->vcolor);
	break;
	case MG_DVERT_NORM:
    printf("\n");
    printf("==============================================================\n");
    printf(" SHADED NORMAL VERTEX RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", ((mgVertSharedNorm *)fltVert)->length);
    printf("x:\t\t\t\t%.3f\n", ((mgVertSharedNorm *)fltVert)->p[0]);
    printf("y:\t\t\t\t%.3f\n", ((mgVertSharedNorm *)fltVert)->p[1]);
    printf("z:\t\t\t\t%.3f\n", ((mgVertSharedNorm *)fltVert)->p[2]);
    printf("Hard Edge Flag:\t\t\t%d\n", ((mgVertSharedNorm *)fltVert)->flags 
								& 0x0001);
    printf("Touch Flag:\t\t\t%d\n", ((mgVertSharedNorm *)fltVert)->flags & 
								0x0002);
    printf("Vertex Color:\t\t\t%d\n", ((mgVertSharedNorm *)fltVert)->vcolor);
    printf("Normals:\t\t\t%.3f %.3f %.3f\n", 
				  	((mgVertSharedNorm *)fltVert)->n[0], 
					((mgVertSharedNorm *)fltVert)->n[1],
					((mgVertSharedNorm *)fltVert)->n[2]);
	break;
	case MG_DVERT_NORM_TEX:
    printf("\n");
    printf("==============================================================\n");
    printf(" SHADED TEXTURED NORMAL VERTEX RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", ((mgVertSharedNormTex *)fltVert)->length);
    printf("x:\t\t\t\t%.3f\n", ((mgVertSharedNormTex *)fltVert)->p[0]);
    printf("y:\t\t\t\t%.3f\n", ((mgVertSharedNormTex *)fltVert)->p[1]);
    printf("z:\t\t\t\t%.3f\n", ((mgVertSharedNormTex *)fltVert)->p[2]);
    printf("Hard Edge Flag:\t\t\t%d\n", ((mgVertSharedNormTex *)fltVert)->flags
                                                                & 0x0001);
    printf("Touch Flag:\t\t\t%d\n", ((mgVertSharedNormTex *)fltVert)->flags &
                                                                0x0002);
    printf("Vertex Color:\t\t\t%d\n", ((mgVertSharedNormTex *)fltVert)->vcolor);
    printf("Normals:\t\t\t%.3f %.3f %.3f\n", 
                                        ((mgVertSharedNormTex *)fltVert)->n[0], 
                                        ((mgVertSharedNormTex *)fltVert)->n[1],
                                        ((mgVertSharedNormTex *)fltVert)->n[2]);
    printf("Textures:\t\t\t%.3f %.3f\n",((mgVertSharedNormTex *)fltVert)->t[0],
					((mgVertSharedNormTex *)fltVert)->t[1]);
	break;
	case MG_DVERT_ABS_TEX:
    printf("\n");
    printf("==============================================================\n");
    printf(" SHADED TEXTURED VERTEX RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", ((mgVertSharedAbsTex *)fltVert)->length);
    printf("x:\t\t\t\t%.3f\n", ((mgVertSharedAbsTex *)fltVert)->p[0]);
    printf("y:\t\t\t\t%.3f\n", ((mgVertSharedAbsTex *)fltVert)->p[1]);
    printf("z:\t\t\t\t%.3f\n", ((mgVertSharedAbsTex *)fltVert)->p[2]);
    printf("Hard Edge Flag:\t\t\t%d\n", ((mgVertSharedAbsTex *)fltVert)->flags
                                                                & 0x0001);
    printf("Touch Flag:\t\t\t%d\n", ((mgVertSharedAbsTex *)fltVert)->flags &
                                                                0x0002);
    printf("Vertex Color:\t\t\t%d\n", ((mgVertSharedAbsTex *)fltVert)->vcolor);
    printf("Textures:\t\t\t%.3f %.3f\n",((mgVertSharedAbsTex *)fltVert)->t[0], 
                                        ((mgVertSharedAbsTex *)fltVert)->t[1]);
	break;
    }
}

/*******************************************************************************
*     Function: print 
*        Class: VertexRecordBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
void VertexRecordBead::print(void) const
{
    printVertexRecord(type, fltVert);
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexTableBead
*       Access: Public
*  Description: Default constructor 
*        Input:
*       Output:
*******************************************************************************/
VertexTableBead::VertexTableBead(void)
{
    type = MG_VTXTABLE;
    strcpy(name, "VERTEX_TABLE");

    fltVertTable.opcode = MG_VTXTABLE;
    fltVertTable.length = FLT_VTXTABLE_LENGTH;
    fltVertTable.vtxlen = FLT_VTXTABLE_LENGTH; // No vertices in pool initially
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
    current = NULL;
    vpool = NULL;
    currentOffset = FLT_VTXTABLE_LENGTH;
    fltflag = 0;  
    sharedVertex = 0;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexTableBead
*       Access: Public
*  Description:  
*        Input: A valid flight vertex table record
*       Output:
*******************************************************************************/
VertexTableBead::VertexTableBead(const mgVertTable& _fltVertTable)
{
    type = MG_VTXTABLE;
    strcpy(name, "VERTEX_TABLE");

    fltVertTable = _fltVertTable;
    currentOffset = FLT_VTXTABLE_LENGTH;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
    vpool = NULL;
    current = vpool;
    fltflag = 1;
    sharedVertex = 1;
}

/*******************************************************************************
*     Function: Destructor
*        Class: VertexTableBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
VertexTableBead::~VertexTableBead()
{
    Bead *temp;

    temp = vpool;
    while (temp->right() != NULL)
	temp = temp->right();
    temp = temp->left();
    while (temp->left() != NULL)
    {
	delete temp->right();
	temp = temp->left();
    }
    delete temp;
}

/*******************************************************************************
*     Function: addVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
int VertexTableBead::addVertex(ushort type, void* fltVert)
{
    int offset;

    VertexRecordBead *bead = new VertexRecordBead(type, fltVert); 
    if (vpool == NULL)
    {
	vpool = bead;
        current = bead;
    }
    else
    {
	current->right(bead);
	bead->left(current);
	current = bead;
    }
   switch (type)
   {
    	case MG_DVERT_ABS:
	    offset = FLT_VERT_SHARED_ABS_LENGTH;
    	break;
    	case MG_DVERT_NORM:
	    offset = FLT_VERT_SHARED_NORM_LENGTH;
     	break;	
    	case MG_DVERT_NORM_TEX:
	    offset = FLT_VERT_SHARED_NORM_TEX_LENGTH;
    	break;
    	case MG_DVERT_ABS_TEX:
	    offset = FLT_VERT_SHARED_ABS_TEX_LENGTH;
        break;
    	default:
    	    fprintf(stderr,"addVertex: Unknown vertex type < %d >\n", type);
	    offset = 0;
    	break;
    }
    if (fltflag == 0) // only increment vtxlen if source is not a flt file
    	fltVertTable.vtxlen += offset;

    current->Offset(currentOffset);
    currentOffset += offset;
    return (current->Offset());
}

/*******************************************************************************
*     Function: addVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
int VertexTableBead::addVertex(double coord[3])
{
    VertexRecordBead *nbead;
    double npoint[3];

    VertexRecordBead *bead = new VertexRecordBead(coord); 
    if (vpool == NULL)
    {
	vpool = bead;
        current = vpool;
    }
    else if (!sharedVertex)
    {
	current->right(bead);
	bead->left(current);	
	current = bead;
    } 
    else
    {
	nbead = vpool;
	while (nbead != NULL)
	{
	    nbead->getPoint(npoint);
	    if ((fabs(npoint[0] - coord[0]) < VERT_FUZZ) &&
	    	(fabs(npoint[1] - coord[1]) < VERT_FUZZ) &&
	    	(fabs(npoint[2] - coord[2]) < VERT_FUZZ))
		return (nbead->Offset());
	    nbead = (VertexRecordBead *)nbead->right();
	}
	current->right(bead);
	bead->left(current);
	current = bead;
    }
    fltVertTable.vtxlen += FLT_VERT_SHARED_ABS_LENGTH;
    current->Offset(currentOffset);
    currentOffset += FLT_VERT_SHARED_ABS_LENGTH;
    return (current->Offset());
}

/*******************************************************************************
*     Function: addVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
int VertexTableBead::addVertex(double coord[3], float norm[3])
{
    VertexRecordBead *nbead;
    double npoint[3];

    VertexRecordBead *bead = new VertexRecordBead(coord, norm); 
    if (vpool == NULL)
    {
	vpool = bead;
        current = bead;
    }
    else if (!sharedVertex)
    {
	current->right(bead);
	bead->left(current);	
	current = bead;
    } 
    else
    {
	nbead = vpool;
	while (nbead != NULL)
	{
	    nbead->getPoint(npoint);
	    if ((fabs(npoint[0] - coord[0]) < VERT_FUZZ) &&
	    	(fabs(npoint[1] - coord[1]) < VERT_FUZZ) &&
	    	(fabs(npoint[2] - coord[2]) < VERT_FUZZ))
		return (nbead->Offset());
	    nbead = (VertexRecordBead *)nbead->right();
	}
	current->right(bead);
	bead->left(current);
	current = bead;
    }
    fltVertTable.vtxlen += FLT_VERT_SHARED_NORM_LENGTH;
    current->Offset(currentOffset);
    currentOffset += FLT_VERT_SHARED_NORM_LENGTH;
    return (current->Offset());
}

/*******************************************************************************
*     Function: addVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
int VertexTableBead::addVertex(double coord[3], float u, float v)
{
    VertexRecordBead *nbead;
    double npoint[3];

    VertexRecordBead *bead = new VertexRecordBead(coord, u, v); 
    if (vpool == NULL)
    {
	vpool = bead;
        current = bead;
    }
    else if (!sharedVertex)
    {
	current->right(bead);
	bead->left(current);	
	current = bead;
    } 
    else
    {
	nbead = vpool;
	while (nbead != NULL)
	{
	    nbead->getPoint(npoint);
	    if ((fabs(npoint[0] - coord[0]) < VERT_FUZZ) &&
	    	(fabs(npoint[1] - coord[1]) < VERT_FUZZ) &&
	    	(fabs(npoint[2] - coord[2]) < VERT_FUZZ))
		return (nbead->Offset());
	    nbead = (VertexRecordBead *)nbead->right();
	}
	current->right(bead);
	bead->left(current);
	current = bead;
    }
    fltVertTable.vtxlen += FLT_VERT_SHARED_ABS_TEX_LENGTH;
    current->Offset(currentOffset);
    currentOffset += FLT_VERT_SHARED_ABS_TEX_LENGTH;
    return (current->Offset());
}

/*******************************************************************************
*     Function: addVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
int VertexTableBead::addVertex(double coord[3], float norm[3], float tex[2])
{
    VertexRecordBead *nbead;
    double npoint[3];

    VertexRecordBead *bead = new VertexRecordBead(coord, norm, tex); 
    if (vpool == NULL)
    {
	vpool = bead;
        current = bead;
    }
    else if (!sharedVertex)
    {
	current->right(bead);
	bead->left(current);	
	current = bead;
    } 
    else
    {
	nbead = vpool;
	while (nbead != NULL)
	{
	    nbead->getPoint(npoint);
	    if ((fabs(npoint[0] - coord[0]) < VERT_FUZZ) &&
	    	(fabs(npoint[1] - coord[1]) < VERT_FUZZ) &&
	    	(fabs(npoint[2] - coord[2]) < VERT_FUZZ))
		return (nbead->Offset());
	    nbead = (VertexRecordBead *)nbead->right();
	}
	current->right(bead);
	bead->left(current);
	current = bead;
    }
    fltVertTable.vtxlen += FLT_VERT_SHARED_NORM_TEX_LENGTH;
    current->Offset(currentOffset);
    currentOffset += FLT_VERT_SHARED_NORM_TEX_LENGTH;
    return (current->Offset());
}

/*******************************************************************************
*     Function: getVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
VertexRecordBead *VertexTableBead::getVertex(int offset)
{
    VertexRecordBead *vtx = vpool;
    while (vtx != NULL)
    {
	if (vtx->Offset() == offset)
	    return vtx;
	vtx = (VertexRecordBead *)vtx->right();
    }
    return NULL;
}

/*******************************************************************************
*     Function: getVertex 
*        Class: VertexTableBead
*       Access: Public
*  Description:
*        Input:
*       Output:
*******************************************************************************/
VertexRecordBead *VertexTableBead::getVertex(const VertexOffsetBead voffset)
{
    int offset = voffset.offset();
    VertexRecordBead *vtx = vpool;
    while (vtx != NULL)
    {
	if (vtx->Offset() == offset)
	    return vtx;
	vtx = (VertexRecordBead *)vtx->right();
    }
    return NULL;
}

/*******************************************************************************
*     Function: printVertexTable
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void printVertexTable(const mgVertTable& fltVertTable)
{
    printf("\n");
    printf("==============================================================\n");
    printf(" VERTEX TABLE HEADER RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", fltVertTable.length);
    printf("Vertex pool length:\t\t\t%d\n", fltVertTable.vtxlen);
}

/*******************************************************************************
*     Function: print
*        Class: VertexTableBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void VertexTableBead::print(void) const
{
    printVertexTable(fltVertTable);
}

/*******************************************************************************
*     Function: printVertPool
*        Class: VertexTableBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void VertexTableBead::printVertPool(void) const
{
    VertexRecordBead *vert;
    printVertexTable(fltVertTable);
    vert = vpool;
    while (vert != NULL)
    {
	printVertexRecord(vert->Type(), vert->fltStruct());
	vert = (VertexRecordBead *)vert->right();
    } 
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexListBead 
*       Access: Public
*  Description: Default constructor 
*        Input: 
*       Output:
*******************************************************************************/
VertexListBead::VertexListBead(void)
{
    type = MG_VTXLIST;
    strcpy(name, DEFAULT_NAME);

    fltVertList.opcode = MG_VTXLIST;
    fltVertList.length = FLT_VERT_LIST_LENGTH; // starts off at 4
    fltflag = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexListBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
VertexListBead::VertexListBead(const mgVertList& _fltVertList)
{
    type = MG_VTXLIST;
    strcpy(name, DEFAULT_NAME);

    fltVertList = _fltVertList;
    fltflag = 1;  // Indicates source was a flight file
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexListBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void VertexListBead::addOffset(void)
{
    // Only increment if source is not a flight file
    if (fltflag != 1)
	fltVertList.length += VERTEX_OFFSET_LENGTH;
}

/*******************************************************************************
*     Function: print 
*        Class: VertexListBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void VertexListBead::print(void) const
{
    printf("\n");
    printf("==============================================================\n");
    printf(" VERTEX LIST RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", fltVertList.length);
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexOffsetBead 
*       Access: Public
*  Description:  
*        Input: A valid offset into the vertex pool 
*       Output:
*******************************************************************************/
VertexOffsetBead::VertexOffsetBead(int offset)
{
    type = MG_VTXOFFSET;
    strcpy(name, DEFAULT_NAME);

    fltVertOffset.vtxoffset = offset; 
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexOffsetBead 
*       Access: Public
*  Description: Default constructor 
*        Input: 
*       Output:
*******************************************************************************/
VertexOffsetBead::VertexOffsetBead(void)
{
    type = MG_VTXOFFSET;
    strcpy(name, DEFAULT_NAME);

    fltVertOffset.vtxoffset = 0;  // Need to determine offset into vertex pool
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: VertexOffsetBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
VertexOffsetBead::VertexOffsetBead(const mgVertOffset& _fltVertOffset)
{
    type = MG_VTXOFFSET;
    strcpy(name, DEFAULT_NAME);

    fltVertOffset = _fltVertOffset;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Destructor
*        Class: VertexOffsetBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
VertexOffsetBead::~VertexOffsetBead(void)
{
}

/*******************************************************************************
*     Function: print 
*        Class: VertexOffsetBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void VertexOffsetBead::print(void) const
{
    printf("\n");
    printf("==============================================================\n");
    printf(" VERTEX OFFSET RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Offset:\t\t\t\t\t%d\n", fltVertOffset.vtxoffset);
}

/*******************************************************************************
*     Function: Constructor
*        Class: GroupBead
*       Access: Public
*  Description: Default constructor 
*        Input: 
*       Output:
*******************************************************************************/
GroupBead::GroupBead(void)
{
    type = MG_GROUP;
    strcpy(name, DEFAULT_NAME);

    fltGroup.opcode = 2;
    fltGroup.length = FLT_GROUP_LENGTH;
    fltGroup.relPri = 0;
    fltGroup.flags = 0;
    fltGroup.fxId1 = 0;
    fltGroup.fxId2 = 0;
    fltGroup.signif = 0;
    fltGroup.layer = 0; 

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: GroupBead
*       Access: Public
*  Description: 
*        Input: 
*       Output:
*******************************************************************************/
GroupBead::GroupBead(char *_name)
{
    type = MG_GROUP;
    strcpy(name, _name);

    fltGroup.opcode = MG_GROUP;
    fltGroup.length = FLT_GROUP_LENGTH;

    // initialize auxiliary data
    aux.matrix = NULL;
    aux.bbox = NULL;
    aux.comment = NULL;
    aux.id = NULL;
    aux.numvert = 0;

    if (strlen(_name) > MAX_SHORT_ID_LENGTH)
    {
	LongID(_name);
	strncpy(fltGroup.id, _name, MAX_SHORT_ID_LENGTH);
    }
    else
    	strcpy(fltGroup.id, _name);
    fltGroup.relPri = 0;
    fltGroup.flags = 0;
    fltGroup.fxId1 = 0;
    fltGroup.fxId2 = 0;
    fltGroup.signif = 0;
    fltGroup.layer = 0; 

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: GroupBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
GroupBead::GroupBead(const mgGroup& _fltGroup)
{
    type = MG_GROUP;
    strcpy(name, _fltGroup.id);

    fltGroup = _fltGroup;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: LongID 
*        Class: GroupBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void GroupBead::LongID(char *name)
{
    // deal with multiple different comments later
    if (aux.id != NULL)
 	fprintf(stderr, "Warning: id field of object already occupied\n");
    aux.id = (mgLongID *)malloc(sizeof(mgLongID));
    aux.id->opcode = MG_LONGID;
    // must consider SGI word alignment when calculating the length field
    int textlength = strlen(name); 
    // word alignment on 32 bytes
    if (textlength % 32)
    	textlength += 4 - (textlength % 4);
    aux.id->length = sizeof(aux.id->opcode) +    
			  sizeof(aux.id->length) +
			  textlength;
    strcpy(aux.id->text, name);
}

/*******************************************************************************
*     Function: printGroup 
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void printGroup(const mgGroup& fltGroup) 
{
    char flag[12];

    printf("\n");
    printf("==============================================================\n");
    printf(" GROUP RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", fltGroup.length);
    printf("Id:\t\t\t\t\t%s\n", fltGroup.id);
    printf("Relative priority:\t\t\t%d\n", fltGroup.relPri);
    strcpy(flag, "FALSE");
    if (fltGroup.flags & 1) strcpy(flag, "TRUE");
    printf("Flag:\tTerrain:\t\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltGroup.flags & 2) strcpy(flag, "TRUE");
    printf("Flag:\tForward animation:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltGroup.flags & 4) strcpy(flag, "TRUE");
    printf("Flag:\tCycling animation:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltGroup.flags & 8) strcpy(flag, "TRUE");
    printf("Flag:\tBounding box follows:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltGroup.flags & 16) strcpy(flag, "TRUE");
    printf("Flag:\tFreeze bounding box:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltGroup.flags & 32) strcpy(flag, "TRUE");
    printf("Flag:\tDefault parent:\t\t\t%s\n", flag);
    printf("Special effects id 1:\t\t\t%d\n", fltGroup.fxId1);
    printf("Special effects id 2:\t\t\t%d\n", fltGroup.fxId2);
    printf("Significance flags:\t\t\t%d\n", fltGroup.signif);
    printf("Layer number:\t\t\t\t%c\n", fltGroup.layer);
}

/*******************************************************************************
*     Function: print 
*        Class: GroupBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void GroupBead::print(void) const
{
    printGroup(fltGroup);
}

/*******************************************************************************
*     Function: Constructor
*        Class: SwitchBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
SwitchBead::SwitchBead(const mgSwitch& _fltSwitch)
{
    type = MG_SWITCH;
    strcpy(name, _fltSwitch.id);

    fltSwitch = _fltSwitch;
    parent = next = prev = child = NULL;
}

/*******************************************************************************
*     Function: print 
*        Class: SwitchBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void SwitchBead::print(void) const
{
}

/*******************************************************************************
*     Function: Constructor
*        Class: DofBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
DofBead::DofBead(const mgDof& _fltDof)
{
    type = MG_DOF;
    strcpy(name, _fltDof.id);

    fltDof = _fltDof;
    parent = next = prev = child = NULL;
}

/*******************************************************************************
*     Function: print 
*        Class: DofBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void DofBead::print(void) const
{
}

/*******************************************************************************
*     Function: Constructor
*        Class: LodBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
LodBead::LodBead(const mgLod& _fltLod)
{
    type = MG_LOD;
    strcpy(name, _fltLod.id);

    fltLod = _fltLod;
    parent = next = prev = child = NULL;
}

/*******************************************************************************
*     Function: print 
*        Class: LodBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void LodBead::print(void) const
{
}

/*******************************************************************************
*     Function: Constructor
*        Class: FLodBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
FLodBead::FLodBead(const mgFLod& _fltLod)
{
    type = MG_LODFLOAT;
    strcpy(name, _fltLod.id);

    fltLod = _fltLod;
    parent = next = prev = child = NULL;
}

/*******************************************************************************
*     Function: print 
*        Class: FLodBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void FLodBead::print(void) const
{
}

/*******************************************************************************
*     Function: Constructor
*        Class: ObjectBead
*       Access: Public
*  Description: Default constructor 
*        Input: 
*       Output:
*******************************************************************************/
ObjectBead::ObjectBead(void)
{
    type = MG_OBJECT;
    strcpy(name, DEFAULT_NAME);

    fltObject.opcode = MG_OBJECT;
    fltObject.length = FLT_OBJECT_LENGTH;
    fltObject.flags = 0;
    fltObject.relPri = 0;
    fltObject.transp = 0;  // Defaults to no transparency
    fltObject.fxId1 = 0;
    fltObject.fxId2 = 0;
    fltObject.signif = 0;
    fltObject.spare1 = 0;

    // initialize auxiliary data
    aux.matrix = NULL;
    aux.bbox = NULL;
    aux.comment = NULL;
    aux.id = NULL;
    aux.numvert = 0;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: ObjectBead
*       Access: Public
*  Description: 
*        Input: 
*       Output:
*******************************************************************************/
ObjectBead::ObjectBead(char *_name)
{
    type = MG_OBJECT;
    strcpy(name, _name);

    fltObject.opcode = MG_OBJECT;
    fltObject.length = FLT_OBJECT_LENGTH;

    // initialize auxiliary data
    aux.matrix = NULL;
    aux.bbox = NULL;
    aux.comment = NULL;
    aux.id = NULL;
    aux.numvert = 0;
  
    if (strlen(_name) > MAX_SHORT_ID_LENGTH)
    {
  	LongID(_name);
	strncpy(fltObject.id, _name, MAX_SHORT_ID_LENGTH);
    }
    else
    	strcpy(fltObject.id, _name);
    fltObject.flags = 0;
    fltObject.relPri = 0;
    fltObject.transp = 0;  // Defaults to no transparency
    fltObject.fxId1 = 0;
    fltObject.fxId2 = 0;
    fltObject.signif = 0;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: ObjectBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
ObjectBead::ObjectBead(const mgObject& _fltObject)
{
    type = MG_OBJECT;
    strcpy(name, _fltObject.id);
    fltObject = _fltObject;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: LongID 
*        Class: ObjectBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void ObjectBead::LongID(char *name)
{
    // deal with multiple different comments later
    if (aux.id != NULL)
 	fprintf(stderr, "Warning: id field of object already occupied\n");
    aux.id = (mgLongID *)malloc(sizeof(mgLongID));
    aux.id->opcode = MG_LONGID;
    // must consider SGI word alignment when calculating the length field
    int textlength = strlen(name); 
    // word alignment on 32 bytes
    if (textlength % 32)
    	textlength += 4 - (textlength % 4);
    aux.id->length = sizeof(aux.id->opcode) +    
			  sizeof(aux.id->length) +
			  textlength;
    strcpy(aux.id->text, name);
}

/*******************************************************************************
*     Function: printObject
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void printObject(const mgObject& fltObject)
{
    char flag[12];

    printf("\n");
    printf("==============================================================\n");
    printf(" OBJECT RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", fltObject.length);
    printf("Id:\t\t\t\t\t%s\n", fltObject.id);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 1) strcpy(flag, "TRUE");
    printf("Flag: Don't display in daylight:\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 2) strcpy(flag, "TRUE");
    printf("Flag: Don't display at dusk:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 4) strcpy(flag, "TRUE");
    printf("Flag: Don't display at night:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 8) strcpy(flag, "TRUE");
    printf("Flag: Don't illuminate:\t\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 16) strcpy(flag, "TRUE");
    printf("Flag: Flat shaded:\t\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 32) strcpy(flag, "TRUE");
    printf("Flag: Group's shadow object:\t\t%s\n", flag);
    strcpy(flag, "FALSE");
    if (fltObject.flags & 64) strcpy(flag, "TRUE");
    printf("Flag: Terrain:\t\t\t\t%s\n", flag);
    printf("Object relative priority:\t\t%d\n", fltObject.relPri);
    printf("Transparency factor:\t\t\t%d\n", fltObject.transp);
    printf("Special effects id 1:\t\t\t%d\n", fltObject.fxId1);
    printf("Special effects id 2:\t\t\t%d\n", fltObject.fxId2);
    printf("Significance:\t\t\t\t%d\n", fltObject.signif);
}

/*******************************************************************************
*     Function: print 
*        Class: ObjectBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void ObjectBead::print(void) const
{
    printObject(fltObject);
}

/*******************************************************************************
*     Function: Constructor
*        Class: PolygonBead
*       Access: Public
*  Description: Default constructor  
*        Input: 
*       Output:
*******************************************************************************/
PolygonBead::PolygonBead(void)
{
    type = MG_POLYGON;
    strcpy(name, DEFAULT_NAME);

    fltPoly.opcode = MG_POLYGON;
    fltPoly.length = FLT_POLYGON_LENGTH;
    fltPoly.IRCode = 0;
    fltPoly.relPri = 0;
    fltPoly.drawType = 0;  // Defaults to draw solid with no backface
    fltPoly.spare1 = 1;  // Defaults to texwhite = TRUE
    fltPoly.color1 = 4096;
    fltPoly.color2 = -1;
    fltPoly.textureTemplate = 0;  // Defaults to no template transparency
    fltPoly.detail = -1;
    fltPoly.texture = -1;
    fltPoly.material = -1;
    fltPoly.surfaceMaterialCode = 0;
    fltPoly.featureId = 0;
    fltPoly.IRMaterial = 0;
    fltPoly.transp = 0;  // Defaults to solid 
    fltPoly.spare4[0] = 0;

    // initialize auxiliary data
    aux.matrix = NULL;
    aux.bbox = NULL;
    aux.comment = NULL;
    aux.id = NULL;
    aux.numvert = 0;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: PolygonBead
*       Access: Public
*  Description:   
*        Input: 
*       Output:
*******************************************************************************/
PolygonBead::PolygonBead(char *_name)
{
    type = MG_POLYGON;
    strcpy(name, _name);

    fltPoly.opcode = MG_POLYGON;
    fltPoly.length = FLT_POLYGON_LENGTH;

// truncate name for now
    if (strlen(_name) > 7)
    {
	fprintf(stderr, "WARNING: truncating name for polygon bead\n");
	_name[6] = '\0';
    }

    strcpy(fltPoly.id, _name);
    fltPoly.IRCode = 0;
    fltPoly.relPri = 0;
    fltPoly.drawType = 0;  // Defaults to draw solid with no backface
    fltPoly.spare1 = 1;  // Defaults to texwhite = TRUE
    fltPoly.color1 = 4096;
    fltPoly.color2 = 0;
    fltPoly.spare2 = 0;
    fltPoly.textureTemplate = 0;  // Defaults to no template transparency
    fltPoly.detail = -1;
    fltPoly.texture = -1;
    fltPoly.material = -1;
    fltPoly.surfaceMaterialCode = 0;
    fltPoly.featureId = 0;
    fltPoly.IRMaterial = 0;
    fltPoly.transp = 0;  // Defaults to solid 
    fltPoly.spare4[0] = 0;

    // initialize auxiliary data
    aux.matrix = NULL;
    aux.bbox = NULL;
    aux.comment = NULL;
    aux.id = NULL;
    aux.numvert = 0;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: PolygonBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
PolygonBead::PolygonBead(const mgPolygon& _fltPoly)
{
    type = MG_POLYGON;

    strcpy(name, _fltPoly.id);

    fltPoly = _fltPoly;

    // initialize auxiliary data
    aux.matrix = NULL;
    aux.bbox = NULL;
    aux.comment = NULL;
    aux.id = NULL;
    aux.numvert = 0;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: comment 
*        Class: PolygonBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void PolygonBead::Comment(char *comment)
{
    // deal with multiple different comments later
    if (aux.comment != NULL)
 	fprintf(stderr, "Warning: comment field of polygon already occupied\n");
    aux.comment = (mgComment *)malloc(sizeof(mgComment));
    aux.comment->opcode = MG_COMMENT;
    // must consider SGI word alignment when calculating the length field
    int textlength = strlen(comment); 
    // word alignment on 32 bytes
    if (textlength % 32)
    	textlength += 4 - (textlength % 4);
    aux.comment->length = sizeof(aux.comment->opcode) +    
			  sizeof(aux.comment->length) +
			  textlength;
    strcpy(aux.comment->text, comment);
}

/*******************************************************************************
*     Function: comment 
*        Class: PolygonBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void PolygonBead::Comment(mgComment& comment)
{
    // deal with multiple different comments later
    if (aux.comment != NULL)
 	fprintf(stderr, "Warning: comment field of polygon already occupied\n");
    aux.comment = &comment;
}

/*******************************************************************************
*     Function: printPolygon 
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void printPolygon(const mgPolygon& fltPoly)
{
    char howdraw[64];

    printf("\n");
    printf("==============================================================\n");
    printf(" POLYGON RECORD\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t\t%d\n", fltPoly.length);
    printf("Id:\t\t\t\t\t%s\n", fltPoly.id);
    printf("IR code:\t\t\t\t%d\n", fltPoly.IRCode);
    printf("Polygon relative priority:\t\t%d\n", fltPoly.relPri);
    switch (fltPoly.drawType) {
    	case 1: strcpy(howdraw, "Draw solid backfaced"); break;
    	case 0: strcpy(howdraw, "Draw solid no backface"); break;
    	case 2: strcpy(howdraw, "Draw wireframe and not closed"); break;
    	case 3: strcpy(howdraw, "Draw closed wireframe"); break;
    	case 4: strcpy(howdraw, "Surround with wireframe in alt. color"); break;
    	case 8: strcpy(howdraw, "Omni-directional light"); break;
    	case 9: strcpy(howdraw, "Uni-directional light"); break;
    	case 10: strcpy(howdraw, "Bi-directional light"); break;
	default: strcpy(howdraw, "Unknown draw code"); break; } 
    printf("Flag:\tDrawtype:\t\t\t%s\n", howdraw);
    if (fltPoly.spare1 == 1) strcpy(howdraw, "TRUE");
    else strcpy(howdraw, "FALSE");
    printf("Texwhite:\t\t\t\t%s\n", howdraw);
    printf("Primary color/intensity code:\t\t%d\n", fltPoly.color1);
    printf("Secondary color code:\t\t\t%d\n", fltPoly.color2);
    switch (fltPoly.textureTemplate) {
	case 0: strcpy(howdraw, "None"); break;
	case 1: strcpy(howdraw, "Fixed"); break;
	case 3: strcpy(howdraw, "Axis type rotate"); break;
	case 5: strcpy(howdraw, "Point rotate"); break;
	default: strcpy(howdraw, "Unknown"); break; }
    printf("Set template transparency:\t\t%s\n", howdraw);
    printf("Detail texture pattern no.:\t\t%d\n", fltPoly.detail);
    printf("Texture pattern no.:\t\t\t%d\n", fltPoly.texture);
    printf("Material code [0-63]:\t\t\t%d\n", fltPoly.material);
    printf("Surface Material code:\t\t\t%d\n", fltPoly.surfaceMaterialCode);
    printf("Feature ID:\t\t\t\t%d\n", fltPoly.featureId);
    printf("IR material code:\t\t\t%d\n", fltPoly.IRMaterial);
    printf("Transparency:\t\t\t\t%x\n", fltPoly.transp);
    printf("Influences LOD generation:\t\t%d\n", fltPoly.spare4[0]);
}

/*******************************************************************************
*     Function: printPolygonAux 
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void printPolygonAux(const polygonAux& aux)
{
    if (aux.comment != NULL)
    	printComment(*aux.comment);
}

/*******************************************************************************
*     Function: print 
*        Class: PolygonBead 
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
void PolygonBead::print(void) const
{
    printPolygon(fltPoly);
    printPolygonAux(aux);
}

/*******************************************************************************
*     Function: Constructor
*        Class: ColorTableBead
*       Access: Public
*  Description: Default color table 
*        Input: 
*       Output:
*******************************************************************************/
ColorTableBead::ColorTableBead(void)
{
    int i;
    FILE *ctabfile;

    type = MG_COLOR_TABLE; 
    strcpy(name, "COLOR_TABLE");

    if ((ctabfile = fopen("ctab.bin", "r")) != NULL)
    {
	if (fread(&fltColTable, sizeof(mgColorTable), 1, ctabfile) <= 0)
	{
	    fprintf(stderr, "Couldn't read <ctab.bin>\n");
	    exit(-1);
	}
	fclose(ctabfile);
    }
    else
    {
	fprintf(stderr, "Couldn't find binary color table file <ctab.bin>\n");
	fprintf(stderr, "Creating text version of colortable\n");
    fltColTable.opcode = MG_COLOR_TABLE;
    fltColTable.length = FLT_COLOR_TABLE_LENGTH;
    mgColorTable *ctab = &fltColTable;

   ctab->color[0][0] = 254; ctab->color[0][1] = 254; ctab->color[0][2] = 254;
   ctab->color[1][0] = 241; ctab->color[1][1] = 166; ctab->color[1][2] = 140;
   ctab->color[2][0] = 239; ctab->color[2][1] = 205; ctab->color[2][2] = 142;
   ctab->color[3][0] = 236; ctab->color[3][1] = 239; ctab->color[3][2] = 142;
   ctab->color[4][0] = 205; ctab->color[4][1] = 239; ctab->color[4][2] = 143;
   ctab->color[5][0] = 172; ctab->color[5][1] = 240; ctab->color[5][2] = 142;
   ctab->color[6][0] = 142; ctab->color[6][1] = 240; ctab->color[6][2] = 152;
   ctab->color[7][0] = 143; ctab->color[7][1] = 239; ctab->color[7][2] = 190;
   ctab->color[8][0] = 141; ctab->color[8][1] = 240; ctab->color[8][2] = 227;
   ctab->color[9][0] = 142; ctab->color[9][1] = 220; ctab->color[9][2] = 239;
   ctab->color[10][0] = 143; ctab->color[10][1] = 184; ctab->color[10][2] = 239;
   ctab->color[11][0] = 144; ctab->color[11][1] = 146; ctab->color[11][2] = 238;
   ctab->color[12][0] = 222; ctab->color[12][1] = 81; ctab->color[12][2] = 32;
   ctab->color[13][0] = 222; ctab->color[13][1] = 158; ctab->color[13][2] = 32;
   ctab->color[14][0] = 222; ctab->color[14][1] = 226; ctab->color[14][2] = 28;
   ctab->color[15][0] = 154; ctab->color[15][1] = 222; ctab->color[15][2] = 31;
   ctab->color[16][0] = 90; ctab->color[16][1] = 222; ctab->color[16][2] = 32;
   ctab->color[17][0] = 29; ctab->color[17][1] = 225; ctab->color[17][2] = 44;
   ctab->color[18][0] = 31; ctab->color[18][1] = 223; ctab->color[18][2] = 129;
   ctab->color[19][0] = 30; ctab->color[19][1] = 224; ctab->color[19][2] = 199;
   ctab->color[20][0] = 30; ctab->color[20][1] = 179; ctab->color[20][2] = 224;
   ctab->color[21][0] = 32; ctab->color[21][1] = 112; ctab->color[21][2] = 223;
   ctab->color[22][0] = 31; ctab->color[22][1] = 31; ctab->color[22][2] = 222;
   ctab->color[23][0] = 173; ctab->color[23][1] = 187; ctab->color[23][2] = 209;
   ctab->color[24][0] = 175; ctab->color[24][1] = 207; ctab->color[24][2] = 193;
   ctab->color[25][0] = 185; ctab->color[25][1] = 208; ctab->color[25][2] = 173;
   ctab->color[26][0] = 205; ctab->color[26][1] = 192; ctab->color[26][2] = 176;
   ctab->color[27][0] = 221; ctab->color[27][1] = 200; ctab->color[27][2] = 218;

    for (i=0; i<MG_CT_FIXED; i++)
    {
        fltColTable.fixedColor[i][0] = 0;
        fltColTable.fixedColor[i][1] = 0;
        fltColTable.fixedColor[i][2] = 0;
    }
  }

    fixedColorCount = 4097;  // 4096 is white
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: ColorTableBead
*       Access: Public
*  Description:  
*        Input: A valid flight color table
*       Output:
*******************************************************************************/
ColorTableBead::ColorTableBead(const mgColorTable& _fltColTable)
{
    type = MG_COLOR_TABLE;
    strcpy(name, "COLOR_TABLE");

    fltColTable = _fltColTable;
    fixedColorCount = 4097; // 4096 is white
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Destructor
*        Class: ColorTableBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
ColorTableBead::~ColorTableBead()
{
}

/*******************************************************************************
*     Function: add
*        Class: ColorTableBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
ulong ColorTableBead::add(short value[3])
{
    if ((fixedColorCount+1) > (TOTAL_INTERP_PLUS_SPARE + NUM_FIXED_COLORS))
    {
	fprintf(stderr,"Warning:out of indices for fixed colors -add failed\n");
	return (0);
    }
    VEC3COPY(fltColTable.fixedColor[fixedColorCount-TOTAL_INTERP_PLUS_SPARE], 
								value);
    return (fixedColorCount++);
}

/*******************************************************************************
*     Function: add
*        Class: ColorTableBead
*       Access: Public
*  Description:  
*        Input: 
*       Output:
*******************************************************************************/
ulong ColorTableBead::add(short value[3], int delta)
{
    ulong i;

    if ((fixedColorCount+1) > (TOTAL_INTERP_PLUS_SPARE + NUM_FIXED_COLORS))
    {
	fprintf(stderr,"Warning:out of indices for fixed colors- add failed\n");
	return (0);
    }
    
    for (i=0; i<(fixedColorCount-TOTAL_INTERP_PLUS_SPARE); i++)
    {
	if ((abs(fltColTable.fixedColor[i][0] - value[0]) < delta) &&
	    (abs(fltColTable.fixedColor[i][1] - value[1]) < delta) &&
	    (abs(fltColTable.fixedColor[i][2] - value[2]) < delta))
{
printf("returning: %d\n", i+TOTAL_INTERP_PLUS_SPARE);
	    return (i+TOTAL_INTERP_PLUS_SPARE);
}
    }
    VEC3COPY(fltColTable.fixedColor[fixedColorCount-TOTAL_INTERP_PLUS_SPARE], 
								value);
    return (fixedColorCount++);
}

/*******************************************************************************
*     Function: printColorTable
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
void printColorTable(const mgColorTable& fltColTable) 
{
    int i;

    printf("\n");
    printf("==============================================================\n");
    printf(" COLOR TABLE\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t%d\n", fltColTable.length);
    printf("Variable Intensity colors\n");
    printf("\nINDEX\tRED\t\tGREEN\t\tBLUE\n");
    printf("---------------------------------------------------\n");

    for (i=0;i<MG_CT_SHADED;i++)
       printf(" %d\t%d\t\t%d\t\t%d\n", i, fltColTable.color[i][0],
                                          fltColTable.color[i][1],
                                          fltColTable.color[i][2]);

    printf("\nFixed intensity colors\n\n");
    printf("INDEX\tRED\t\tGREEN\t\tBLUE\n");
    printf("---------------------------------------------------\n");

    for (i=0;i<MG_CT_FIXED;i++)
       printf(" %d\t%d\t\t%d\t\t%d\n", i, fltColTable.fixedColor[i][0],
                                          fltColTable.fixedColor[i][1],
                                          fltColTable.fixedColor[i][2]);
}

/*******************************************************************************
*     Function: convertRGB  
*  Description: Converts an index into the color table into an RGB value
*        Input: 
*       Output:
*******************************************************************************/
uint convertRGB(const mgColorTable& fltColTable, short index, double color[3]) 
{
    int row, col;

    if (index > (TOTAL_INTERP_PLUS_SPARE + NUM_FIXED_COLORS))
	return 0;
    
    if (index < TOTAL_INTERP_COLORS)
    {
	col = index / COLOR_INTENSITIES;
	row = index - (col * COLOR_INTENSITIES);

	color[0] = fltColTable.color[col][0] * row / COLOR_INTENSITIES;
	color[1] = fltColTable.color[col][1] * row / COLOR_INTENSITIES;
	color[2] = fltColTable.color[col][2] * row / COLOR_INTENSITIES;
    }
    else if (index < TOTAL_INTERP_PLUS_SPARE)
    {
	color[0] = color[1] = color[2] = 0.0;  // Currently unused by MultiGen
	return 0;
    }
    else
    {
	color[0] = fltColTable.fixedColor[index - TOTAL_INTERP_PLUS_SPARE][0];
	color[1] = fltColTable.fixedColor[index - TOTAL_INTERP_PLUS_SPARE][1];
	color[2] = fltColTable.fixedColor[index - TOTAL_INTERP_PLUS_SPARE][2];
    }
    return 1;
}

/*******************************************************************************
*     Function: print 
*        Class: ColorTableBead
*       Access: Public
*  Description:
*        Input: 
*       Output:
*******************************************************************************/
void ColorTableBead::print(void) const
{
    printColorTable(fltColTable);
}

/*******************************************************************************
*     Function: Constructor
*        Class: MaterialTableBead
*       Access: Public
*  Description: Default constructor 
*        Input:
*       Output:
*******************************************************************************/
MaterialTableBead::MaterialTableBead(void)
{
    FILE *mtabfile;

    type = MG_MATERIAL_TABLE;
    strcpy(name, "MATERIAL_TABLE");

    if ((mtabfile = fopen("mtab.bin", "r")) != NULL)
    {
	if (fread(&fltMatTable, sizeof(mgMaterialTable), 1, mtabfile) <= 0)
	{
	    fprintf(stderr, "Couldn't read <mtab.bin>\n");
	    exit(-1);
	}
	fclose(mtabfile);
    }
    else
    	fprintf(stderr,"Couldn't find binary material table file <mtab.bin>\n");

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Constructor
*        Class: MaterialTableBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
MaterialTableBead::MaterialTableBead(const mgMaterialTable& _fltMatTable)
{
    type = MG_MATERIAL_TABLE;
    strcpy(name, "MATERIAL_TABLE");

    fltMatTable = _fltMatTable;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: printMaterialTable
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void printMaterialTable(const mgMaterialTable& fltMatTable, int matCnt) 
{
    int  matNdx;
    char flag[12];

    if (matCnt == 0)
	matCnt = NUM_MATERIALS;

    printf("\n");
    printf("==============================================================\n");
    printf(" MATERIAL TABLE\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t%d\n", fltMatTable.length);
    for (matNdx=0;matNdx<matCnt;matNdx++)
    {
       printf("\nMat #%d\tAmbient Diffuse Specular Emissive Shininess Alpha\n",
              matNdx);
       printf("---------------------------------------------------------\n");
       printf("Red\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\t%.3f\n",
              fltMatTable.mat[matNdx].ambient[0],
              fltMatTable.mat[matNdx].diffuse[0],
              fltMatTable.mat[matNdx].specular[0],
              fltMatTable.mat[matNdx].emission[0],
              fltMatTable.mat[matNdx].shininess,
              fltMatTable.mat[matNdx].alpha);
       printf("Green\t%.3f\t%.3f\t%.3f\t%.3f\n",
              fltMatTable.mat[matNdx].ambient[1],
              fltMatTable.mat[matNdx].diffuse[1],
              fltMatTable.mat[matNdx].specular[1],
              fltMatTable.mat[matNdx].emission[1]);
       printf("Blue\t%.3f\t%.3f\t%.3f\t%.3f\n",
              fltMatTable.mat[matNdx].ambient[2],
              fltMatTable.mat[matNdx].diffuse[2],
              fltMatTable.mat[matNdx].specular[2],
              fltMatTable.mat[matNdx].emission[2]);
       strcpy(flag, "FALSE");
       if (fltMatTable.mat[matNdx].spare1[0] & 0x1) strcpy(flag, "TRUE");
       printf("Flag:\tMaterial used:\t\t\t%s\n", flag);
    }
}

/*******************************************************************************
*     Function: print 
*        Class: MaterialTableBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void MaterialTableBead::print(void) const
{
    printMaterialTable(fltMatTable, NUM_MATERIALS);
}

/*******************************************************************************
*     Function: constructor 
*        Class: TextureBead
*       Access: Public
*  Description: Default constructor 
*        Input:
*       Output:
*******************************************************************************/
TextureBead::TextureBead(void)
{
    type = MG_TEXTURE_REF;
    strcpy(name, "DEFAULT");
    strcpy(path, "DEFAULT");

    fltTexRef.opcode = MG_TEXTURE_REF;
    fltTexRef.length = sizeof(mgTextureRef);
    strcpy(fltTexRef.file, "DEFAULT.rgb");	 
    fltTexRef.index = 0;
    fltTexRef.x = 0;
    fltTexRef.y = 0;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: constructor 
*        Class: TextureBead
*       Access: Public
*  Description:  
*        Input: Texture file name, index # and coordinates in texture pallette
*       Output:
*******************************************************************************/
TextureBead::TextureBead(char *texfilename, long index, long x, long y)
{
    type = MG_TEXTURE_REF;
    strcpy(name, "MG_TEXTURE_REF");
    strcpy(path, texfilename);

    fltTexRef.opcode = MG_TEXTURE_REF;
    fltTexRef.length = sizeof(mgTextureRef);

    if (strlen(texfilename) > 79)
    {
	fprintf(stderr, "WARNING: truncating file name for texture ref bead\n");
	texfilename[78] = '\0';
    }

    strcpy(fltTexRef.file, texfilename);	 
    fltTexRef.index = index;
    fltTexRef.x = x;
    fltTexRef.y = y;
    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: constructor 
*        Class: TextureBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
TextureBead::TextureBead(const mgTextureRef& _fltTexRef)
{
    type = MG_TEXTURE_REF;
    strcpy(name, "MG_TEXTURE_REF");
    strcpy(path, _fltTexRef.file);
    fltTexRef = _fltTexRef;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Destructor 
*        Class: TextureBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
TextureBead::~TextureBead()
{
}

/*******************************************************************************
*     Function: printTextureRef
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void printTextureRef(const mgTextureRef& fltTexRef) 
{
    printf("\n");
    printf("==============================================================\n");
    printf(" TEXTURE REFERENCE\n");
    printf("--------------------------------------------------------------\n");
    printf("Length:\t\t\t\t%d\n", fltTexRef.length);
    printf("Filename:\t\t\t%s\n", fltTexRef.file);
    printf("Index:\t\t\t\t%ld\n", fltTexRef.index);
    printf("Pallette x coord:\t\t%ld\n", fltTexRef.x);
    printf("Pallette y coord:\t\t%ld\n", fltTexRef.y);
}

/*******************************************************************************
*     Function: print 
*        Class: TextureBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void TextureBead::print(void) const
{
    printTextureRef(fltTexRef);
}

/*******************************************************************************
*     Function: constructor 
*        Class: TextureAttrBead
*       Access: Public
*  Description: Default constructor 
*        Input:
*       Output:
*******************************************************************************/
TextureAttrBead::TextureAttrBead(void)
{
    type = MG_TEXTURE_ATTR;
    strcpy(name, "DEFAULT");
    strcpy(path, "DEFAULT.rgb.attr");

    fltTexAttr.width = 2;  // # texels in u direction
    fltTexAttr.height = 2; // # texels in v direction
    fltTexAttr.rwsizeu = 1;  // real world size in u direction
    fltTexAttr.rwsizev = 1;  // real world size in v direction
    fltTexAttr.type = 4;  // Defaults to RGB
    fltTexAttr.minfilter = TX_MIPMAP_TRILINEAR;
    fltTexAttr.magfilter = TX_BILINEAR;
    fltTexAttr.wrap = TX_REPEAT;
    fltTexAttr.wrapu = 0;
    fltTexAttr.wrapv = 0;
    fltTexAttr.i1 = 0;
    fltTexAttr.j1 = 0;
    fltTexAttr.envtype = TV_MODULATE;
    fltTexAttr.rwsizeuf = 1.0;
    fltTexAttr.rwsizevf = 1.0;
    fltTexAttr.internalformat = 0;  // Default format
    fltTexAttr.externalformat = TX_PACK_8;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: constructor 
*        Class: TextureAttrBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
TextureAttrBead::TextureAttrBead(const mgTextureAttr& _fltTexAttr)
{
    type = MG_TEXTURE_ATTR;
    strcpy(name, "MG_TEXTURE_ATTR");
    fltTexAttr = _fltTexAttr;

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: constructor 
*        Class: TextureAttrBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
TextureAttrBead::TextureAttrBead(char *texfilename, uint size)
{
    FILE *attrfile;
    type = MG_TEXTURE_ATTR;
    strcpy(name, "MG_TEXTURE_ATTR");
    strcpy(path, texfilename);
    strcat(path, ".attr");

    if ((attrfile = fopen("attr.bin", "r")) != NULL)
    {
	if (fread(&fltTexAttr, sizeof(mgTextureAttr), 1, attrfile) <= 0)
	{
	     fprintf(stderr, "Couldn't read from <attr.bin>\n");
	     exit (-1);
	}
	fclose(attrfile);
	fltTexAttr.width = size;
	fltTexAttr.height = size;
//	fltTexAttr.magfilter = TX_POINT;
        fltTexAttr.wrap = TX_CLAMP;
    }
    else
    {
	fprintf(stderr, "Couldn't load default attribute file <attr.bin>\n");\
	fprintf(stderr, "Using text defaults\n");
     

    fltTexAttr.width = size;  // # texels in u direction
    fltTexAttr.height = size; // # texels in v direction
    fltTexAttr.rwsizeu = 1000;  // real world size in u direction
    fltTexAttr.rwsizev = 1000;  // real world size in v direction
    fltTexAttr.iup = 64;  // i direction considered to be up
    fltTexAttr.jup = 0;   // j direction considered to be up
    fltTexAttr.type = 4;  // Defaults to RGB
    fltTexAttr.minfilter = TX_MIPMAP_TRILINEAR;
    fltTexAttr.magfilter = TX_BILINEAR;
    fltTexAttr.wrap = TX_CLAMP;
    fltTexAttr.wrapu = 0;
    fltTexAttr.wrapv = 0;
    fltTexAttr.changed = 0;
    fltTexAttr.i1 = 0;
    fltTexAttr.j1 = 0;
    fltTexAttr.envtype = TV_MODULATE;
    fltTexAttr.spareia = 0;  // Don't want alpha intensity pattern

    fltTexAttr.rwsizeuf = 1000.0;
    fltTexAttr.rwsizevf = 1000.0;

    fltTexAttr.internalformat = 0;  // Default format
    fltTexAttr.externalformat = 0;  

    fltTexAttr.usefilter = 0;  // TRUE indicates the following 8 floats are
			       // used as MIPMAP kernel

    fltTexAttr.controlpoint = 0;  // Don't send lod or scale next

    fltTexAttr.magfilteralpha = TX_BILINEAR;
    fltTexAttr.magfiltercolor = TX_BILINEAR;

    fltTexAttr.detail = 0;  // Next 5 integers are not a detail texture

    fltTexAttr.tile = 0;  // Next four floats are not a tile
   }

    parent = NULL;
    next = NULL;
    prev = NULL;
    child = NULL;
}

/*******************************************************************************
*     Function: Destructor 
*        Class: TextureAttrBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
TextureAttrBead::~TextureAttrBead()
{
}

/*******************************************************************************
*     Function: Write 
*        Class: TextureAttrBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
uint TextureAttrBead::Write(void)
{
    if ((file = fopen(path, "w")) == NULL)
    {
	fprintf(stderr, "Couldn't open texture attribute file: %s\n", path);
	return (0);
    }
    if (fwrite(&fltTexAttr, sizeof(mgTextureAttr), 1, file) <= 0)
    {
	fprintf(stderr, "Couldn't read from texture attribute file: %s\n",
								path);
	return (0);
    }
    fclose(file);
    return (1);
}

/*******************************************************************************
*     Function: printTextureAttr
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void printTextureAttr(const mgTextureAttr& fltTexAttr) 
{
    printf("\n");
    printf("==============================================================\n");
    printf(" TEXTURE ATTRIBUTE\n");
    printf("--------------------------------------------------------------\n");
    printf("Number of texels in u direction:\t%ld\n", fltTexAttr.width);
    printf("Number of texels in v direction:\t%ld\n", fltTexAttr.height);
    printf("Real world size u:\t\t\t%.2f\n", fltTexAttr.rwsizeuf);
    printf("Real world size v:\t\t\t%.2f\n", fltTexAttr.rwsizevf);
}

/*******************************************************************************
*     Function: print 
*        Class: TextureAttrBead
*       Access: Public
*  Description:  
*        Input:
*       Output:
*******************************************************************************/
void TextureAttrBead::print(void) const
{
    printTextureAttr(fltTexAttr);
}