gls_glo_file.h

Go to the documentation of this file.

/*! \file
  \brief  Provides classes for reading and writing GL Studio Object initialization files
          (GLO files).

  \par Copyright Information

  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>

  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.

  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.

  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).

  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.

*/
#if !defined( _GLS_GLO_FILE_H_ )
#    define _GLS_GLO_FILE_H_

#    include "display_frame.h"
#    include "dynamic_array.h"
#    include "gls_include.h"
#    include "gls_matrix_affine.h"
#    include "vertex.h"

//////////////////// Provides support for creating DLLs ////////////////////////
#    if( defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
        && defined( _MSC_VER )
#        if defined( GLS_EXPORT_GENERATED )
#            define GLSGEN_GlsGloFile_EXPORT __declspec( dllexport )
#        else
#            define GLSGEN_GlsGloFile_EXPORT __declspec( dllimport )
#        endif
#    else
#        define GLSGEN_GlsGloFile_EXPORT
#    endif

namespace disti
{
// Forward declarations.
class DisplayFrame;
class GlsGloFileAttribute;

// Byte swapping functions used by this class.
float          SwapFloatToNet( float val );
double         SwapDoubleToNet( double val );
unsigned int   SwapLongToNet( unsigned int val );
unsigned int   SwapSignedLongToNet( int val );
unsigned short SwapShortToNet( unsigned short val );
short          SwapSignedShortToNet( short val );

// Exception thrown from GlsGloFile contstructor
class GLSGEN_GlsGloFile_EXPORT GlsGloFileNotFoundException
{
};

class GlsGloFile
{
public:
    // Forward declarations.
    class WriteBuffer;

    static const unsigned int NUM_OBJECTS_OFFSET = 16;

    /** The size of the timestamp written into the GLO file. */
    static const unsigned int GLO_FILE_TIMESTAMP_SIZE = 6;

    // Object Initializer Enumeration
    enum
    {
        // From display_types.h
        GLS_GLO_INSTANCE_NAME = 1,
        GLS_GLO_LOCATION,
        GLS_GLO_ROTATION_POINT,
        GLS_GLO_ACTION_CALLBACK,
        GLS_GLO_OBJECT_NAME,
        GLS_GLO_ATTRIBUTE_NAME,
        GLS_GLO_TEXTURE_INDEX,
        GLS_GLO_TEXTURE_REPEAT,
        GLS_GLO_TEXTURE_MAP_MODE,
        GLS_GLO_TEXTURE_MIN_FILTER,
        GLS_GLO_TEXTURE_MAG_FILTER,
        GLS_GLO_TEXTURE_BLEND_COLOR,
        GLS_GLO_TEXTURE_ROTATION,
        GLS_GLO_TEXTURE_SCALE_H,
        GLS_GLO_TEXTURE_SCALE_V,
        GLS_GLO_TEXTURE_OFFSET_X,
        GLS_GLO_TEXTURE_OFFSET_Y,
        GLS_GLO_POLYGON_MODE,
        GLS_GLO_POLYGON_END,
        GLS_GLO_POLYGON_OFFSET,
        GLS_GLO_COLOR,
        GLS_GLO_COLOR_MATERIAL_MODE,
        GLS_GLO_LINE_WIDTH,
        GLS_GLO_LINE_STIPPLE_PATTERN,
        GLS_GLO_LINE_STIPPLE_MULTIPLIER,
        GLS_GLO_VISIBILITY,
        GLS_GLO_CULLBACKFACE,
        GLS_GLO_ALPHAMODE,
        GLS_GLO_ANTIALIAS,
        GLS_GLO_ZBUFFER,
        GLS_GLO_SHADING,
        GLS_GLO_BLINKING,
        GLS_GLO_BLINK_RATE,
        GLS_GLO_PICKABLE,
        GLS_GLO_LIGHTING_ENABLED,
        GLS_GLO_MATERIAL_INDEX,
        GLS_GLO_MATERIAL_INDICES,
        GLS_GLO_DCS_MATRIX,
        GLS_GLO_COMPONENT_ABSOLUTE_PLACEMENT,
        GLS_GLO_COMPONENT_EDITOR_TRANSFORM,
        GLS_GLO_TEXTURE_POINTS,

        // From component_base.h
        GLS_GLO_COMPONENT_USE_PARENT_LIGHTING,

        // From display.h
        GLS_GLO_NEED_CALCULATE,
        GLS_GLO_NEED_PREDRAW,
        GLS_GLO_NUMBER_OF_VERTICES,
        GLS_GLO_VERTICES,
        GLS_GLO_NORMALS,
        GLS_GLO_TEXTURE_COORDINATES,

        // From gls_cylinder.h
        GLS_GLO_CYLINDER_COLOR,
        GLS_GLO_CYLINDER_SEGMENTS,
        GLS_GLO_CYLINDER_FACES,
        GLS_GLO_CYLINDER_FACE_START,
        GLS_GLO_CYLINDER_FACE_END,
        GLS_GLO_CYLINDER_TOP_SIZE,
        GLS_GLO_CYLINDER_BOTTOM_SIZE,
        GLS_GLO_CYLINDER_TOP_FACE,
        GLS_GLO_CYLINDER_BOTTOM_FACE,
        GLS_GLO_CYLINDER_RADII,

        // From gls_eyepoint.h
        GLS_GLO_EYEPOINT_FOV,
        GLS_GLO_EYEPOINT_ORTHOGRAPHIC,
        GLS_GLO_EYEPOINT_ORTHO_SIZE,
        GLS_GLO_EYEPOINT_FOV_IS_HORIZONTAL,
        GLS_GLO_EYEPOINT_ASPECT,
        GLS_GLO_EYEPOINT_NEAR_CLIP,
        GLS_GLO_EYEPOINT_FAR_CLIP,
        GLS_GLO_EYEPOINT_MAINTAIN_ASPECT,
        GLS_GLO_EYEPOINT_VIEW_VECTORS,
        GLS_GLO_EYEPOINT_OTHER_FOV,
        GLS_GLO_EYEPOINT_OTHER_ORTHO_SIZE,
        GLS_GLO_EYEPOINT_HORIZONTAL_CONSTRAINT,
        GLS_GLO_EYEPOINT_VERTICAL_CONSTRAINT,

        // From gls_light_source.h
        GLS_GLO_LIGHT_SOURCE_AMBIENT,
        GLS_GLO_LIGHT_SOURCE_DIFFUSE,
        GLS_GLO_LIGHT_SOURCE_SPECULAR,
        GLS_GLO_LIGHT_SOURCE_SPOT_CUTOFF,
        GLS_GLO_LIGHT_SOURCE_SPOT_EXPONENT,
        GLS_GLO_LIGHT_SOURCE_CONSTANT_ATTENUATION,
        GLS_GLO_LIGHT_SOURCE_LINEAR_ATTENUATION,
        GLS_GLO_LIGHT_SOURCE_QUADRATIC_ATTENUATION,
        GLS_GLO_LIGHT_SOURCE_LIGHT_TYPE,

        // From gls_sphere.h
        GLS_GLO_SPHERE_MAPPING,
        GLS_GLO_SPHERE_COLOR,
        GLS_GLO_SPHERE_STACKS,
        GLS_GLO_SPHERE_SLICES,
        GLS_GLO_SPHERE_SLICE_START,
        GLS_GLO_SPHERE_SLICE_END,
        GLS_GLO_SPHERE_STACK_START,
        GLS_GLO_SPHERE_STACK_END,
        GLS_GLO_SPHERE_RADII,

        // from gls_text.h
        GLS_GLO_TEXT_BORDER,
        GLS_GLO_TEXT_CELL_HEIGHT,
        GLS_GLO_TEXT_CELL_WIDTH,
        GLS_GLO_TEXT_CONSTRAIN_CELL_RATIO,
        GLS_GLO_TEXT_CONTROL_CELL_SIZE,
        GLS_GLO_TEXT_FONT,
        GLS_GLO_TEXT_HALO,
        GLS_GLO_TEXT_LINESPACING,
        GLS_GLO_TEXT_LOCK_CELL_SIZE,
        GLS_GLO_TEXT_JUSTIFY,
        GLS_GLO_TEXT_SHADOW,
        GLS_GLO_TEXT_STRING,
        GLS_GLO_TEXT_UPPERCASE,
        GLS_GLO_TEXT_WRAP,
        GLS_GLO_TEXT_HALO_COLOR,
        GLS_GLO_TEXT_SHADOW_COLOR,
        GLS_GLO_TEXT_SHADOW_DISTANCE,
        GLS_GLO_TEXT_BASELINE,
        GLS_GLO_TEXT_BG_COLOR,
        GLS_GLO_TEXT_TEXT_COLOR,
        GLS_GLO_TEXT_CHAR_SCALING,
        GLS_GLO_TEXT_CHAR_SPACING,
        GLS_GLO_TEXT_FAUX_BOLD,
        GLS_GLO_TEXT_INVERSE,
        GLS_GLO_TEXT_STRIKE_THRU,
        GLS_GLO_TEXT_UNDERLINE,

        // From gltrimesh.h
        GLS_GLO_TRIMESH_FIRST_VALUE,
        GLS_GLO_TRIMESH_USE_DISPLAY_LIST,
        GLS_GLO_TRIMESH_FACES,

        // From gls_3d_cable.h
        GLS_GLO_3DCABLE_FIRST_VALUE,
        GLS_GLO_3DCABLE_FLEXIBILITY,
        GLS_GLO_3DCABLE_NUMBEROFSEGMENTS,
        GLS_GLO_3DCABLE_NUMBEROFSIDES,
        GLS_GLO_3DCABLE_RADIUS,
        GLS_GLO_3DCABLE_LENGTH,
        GLS_GLO_3DCABLE_GRAVITY,
        GLS_GLO_3DCABLE_SECTIONSLACKPCT,
        GLS_GLO_3DCABLE_SECTIONFLOORDIST,
        GLS_GLO_3DCABLE_COLLISIONSTYLE,
        GLS_GLO_3DCABLE_FILLCOLOR,
        GLS_GLO_3DCABLE_LINECOLOR,

        // From gls_button.h
        GLS_GLO_GLSBUTTON_CHANGE_CALLBACK,
        GLS_GLO_GLSBUTTON_TOGGLE,
        GLS_GLO_GLSBUTTON_WHICH_OBJ_POS_UP,
        GLS_GLO_GLSBUTTON_WHICH_OBJ_POS_DOWN,
        GLS_GLO_GLSBUTTON_STATE,
        GLS_GLO_GLSBUTTON_EMIT_STATE_CHANGE_EVENT,

        // From gls_angular_scale.h
        GLS_GLO_ANGULAR_SCALE_FIRST_VALUE,
        GLS_GLO_ANGULAR_SCALE_RADII,
        GLS_GLO_ANGULAR_SCALE_DECONFLICT_TICKS,
        GLS_GLO_ANGULAR_SCALE_HALO_ENABLED,
        GLS_GLO_ANGULAR_SCALE_HALO_WIDTH,
        GLS_GLO_ANGULAR_SCALE_HALO_COLOR,
        GLS_GLO_ANGULAR_SCALE_USE_SCALABLE_LINES,
        GLS_GLO_ANGULAR_SCALE_RADIUS,
        GLS_GLO_ANGULAR_SCALE_DATA,

        // From gls_clipping_group.h
        GLS_GLO_CLIPPING_GROUP_STATE,
        GLS_GLO_CLIPPING_GROUP_CLIPPING_ACTIVE,
        GLS_GLO_CLIPPING_GROUP_BOTTOM_LEFT_CORNER,
        GLS_GLO_CLIPPING_GROUP_TOP_RIGHT_CORNER,
        GLS_GLO_CLIPPING_GROUP_SHOW_OUTLINE,

        // From gls_dynamic_path.h
        GLS_GLO_DYNAMICPATH_FIRST_VALUE,
        GLS_GLO_DYNAMICPATH_AFFECTS_LOCATION_X,
        GLS_GLO_DYNAMICPATH_AFFECTS_LOCATION_Y,
        GLS_GLO_DYNAMICPATH_AFFECTS_LOCATION_Z,
        GLS_GLO_DYNAMICPATH_AFFECTS_ROTATION_X,
        GLS_GLO_DYNAMICPATH_AFFECTS_ROTATION_Y,
        GLS_GLO_DYNAMICPATH_AFFECTS_ROTATION_Z,
        GLS_GLO_DYNAMICPATH_AFFECTS_SCALE_X,
        GLS_GLO_DYNAMICPATH_AFFECTS_SCALE_Y,
        GLS_GLO_DYNAMICPATH_AFFECTS_SCALE_Z,
        GLS_GLO_DYNAMICPATH_USE_SHORT_ROTATION_PATHS,
        GLS_GLO_DYNAMICPATH_STATE_COUNT,
        GLS_GLO_DYNAMICPATH_STATE,

        // From gls_mutex_group.h
        GLS_GLO_MUTEX_GROUP_STATE,
        GLS_GLO_MUTEX_GROUP_CALC_INVISIBLE_STATES,
        GLS_GLO_MUTEX_GROUP_PICK_INVISIBLE_STATES,
        GLS_GLO_MUTEX_GROUP_PREDRAW_INVISIBLE_STATES,
        GLS_GLO_MUTEX_GROUP_INPUT_DEVICE_BEHAVIOR,

        // From gls_multi_view.h
        GLS_GLO_GLSMULTIVIEW_FIRST_VALUE,
        GLS_GLO_GLSMULTIVIEW_VIEW_DATA,
        GLS_GLO_GLSMULTIVIEW_VIEW_DRAWING_STATE,

        // From gls_linear_scale.h
        GLS_GLO_LINEAR_SCALE_FIRST_VALUE,
        GLS_GLO_LINEAR_SCALE_RADII,
        GLS_GLO_LINEAR_SCALE_DECONFLICT_TICKS,
        GLS_GLO_LINEAR_SCALE_HALO_ENABLED,
        GLS_GLO_LINEAR_SCALE_HALO_WIDTH,
        GLS_GLO_LINEAR_SCALE_HALO_COLOR,
        GLS_GLO_LINEAR_SCALE_TICK_ANCHOR,
        GLS_GLO_LINEAR_SCALE_USE_SCALABLE_LINES,
        GLS_GLO_LINEAR_SCALE_DATA,

        // From gls_knob.h
        GLS_GLO_GLSKNOB_CHANGE_CALLBACK,
        GLS_GLO_GLSKNOB_ANGLERANGE,
        GLS_GLO_GLSKNOB_CONTINUOUS,
        GLS_GLO_GLSKNOB_POSITIONVAL,
        GLS_GLO_GLSKNOB_DETENTPOSITIONS,
        GLS_GLO_GLSKNOB_WHICHOBJECT,
        GLS_GLO_GLSKNOB_STARTANGLE,
        GLS_GLO_GLSKNOB_EMITDETENTVALEVENT,
        GLS_GLO_GLSKNOB_EMITPOSITIONVALEVENT,
        GLS_GLO_GLSKNOB_EMITLIMITEVENT,
        GLS_GLO_GLSKNOB_EMITRELEASEEVENT,
        GLS_GLO_GLSKNOB_SHOWDETENTSONLY,
        GLS_GLO_GLSKNOB_CLICKSELECTSDETENT,

        // From gls_ellipse.h
        GLS_GLO_ELLIPSE_FIRST_VALUE,
        GLS_GLO_ELLIPSE_RADII,
        GLS_GLO_ELLIPSE_THICKNESS,
        GLS_GLO_ELLIPSE_SOLID,
        GLS_GLO_ELLIPSE_INTERVAL,
        GLS_GLO_ELLIPSE_START_ANGLE,
        GLS_GLO_ELLIPSE_END_ANGLE,
        GLS_GLO_ELLIPSE_COLOR,

        // From gls_switch.h
        GLS_GLO_GLSSWITCH_INITIAL_DETENT_VAL,
        GLS_GLO_GLSSWITCH_WHICH_OBJECT_BACKGROUND,
        GLS_GLO_GLSSWITCH_FIRST_DETENT_SNAPBACK,
        GLS_GLO_GLSSWITCH_LAST_DETENT_SNAPBACK,
        GLS_GLO_GLSSWITCH_EMIT_DETENT_VAL_EVENT,
        GLS_GLO_GLSSWITCH_EMIT_LIMIT_EVENT,
        GLS_GLO_GLSSWITCH_EMIT_RELEASE_EVENT,

        // From gls_thumb_wheel.h
        GLS_GLO_GLSTHUMBWHEEL_INITIAL_VAL,
        GLS_GLO_GLSTHUMBWHEEL_EMIT_DETENT_VAL_EVENT,
        GLS_GLO_GLSTHUMBWHEEL_EMIT_LIMIT_EVENT,
        GLS_GLO_GLSTHUMBWHEEL_EMIT_RELEASE_EVENT,
        GLS_GLO_GLSTHUMBWHEEL_NUMBER_OF_DETENTS,
        GLS_GLO_GLSTHUMBWHEEL_CONTINUOUS_DRAG,
        GLS_GLO_GLSTHUMBWHEEL_DETENT_VAL,
        GLS_GLO_GLSTHUMBWHEEL_WHICH_OBJECT_THUMBWHEEL,
        GLS_GLO_GLSTHUMBWHEEL_WHICH_OBJECT_ODOMETER,
        GLS_GLO_GLSTHUMBWHEEL_SOUND_INDEX,

        // From gls_text_grid.h
        GLS_GLO_TEXT_GRID_SIZE,
        GLS_GLO_TEXT_GRID_LEFT_TO_RIGHT,

        // From gls_schematic_tee_interconnect.h
        GLS_GLO_SCHEMATICTEEINTERCONNECT_FIRST_VALUE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_LINE_THICKNESS,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_LINE_THICKNESS,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_LINE_THICKNESS,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_INTERCONNECT_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_INTERCONNECT_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_INTERCONNECT_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_INTERCONNECT_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_INTERCONNECT_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_INTERCONNECT_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_FLOW_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_FLOW_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_FLOW_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_FLOW_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_FLOW_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_FLOW_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_SHOW_FLOW,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_SHOW_FLOW,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_SHOW_FLOW,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_FLOW_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_FLOW_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_FLOW_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_SHOW_FLOW_BLINK,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_SHOW_FLOW_BLINK,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_SHOW_FLOW_BLINK,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_FLOW_BLINK_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_FLOW_BLINK_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_FLOW_BLINK_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_FLOW_BLINK_START_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_FLOW_BLINK_START_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_FLOW_BLINK_START_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_LEFT_FLOW_BLINK_END_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_RIGHT_FLOW_BLINK_END_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_BASE_FLOW_BLINK_END_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_USE_DISPLAY_LIST,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_VISIBLE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_LINE_THICKNESS,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_INTERCONNECT_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_INTERCONNECT_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_FLOW_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_FLOW_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_SHOW_FLOW,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_FLOW_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_SHOW_FLOW_BLINK,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_FLOW_BLINK_RATE,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_FLOW_BLINK_START_COLOR,
        GLS_GLO_SCHEMATICTEEINTERCONNECT_TOP_FLOW_BLINK_END_COLOR,

        // From gls_schematic_polyline_interconnect.h
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FIRST_VALUE,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_ORIENTATION,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_LINE_THICKNESS,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_ROUNDED_CORNERS,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_CORNER_RADIUS,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FORCE_EXACT_CORNER_RADIUS,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_CORNER_SEGMENTS,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_INTERCONNECT_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FLOW_TEXTURE_INDEX,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FLOW_TEXTURE_REPEAT_LENGTH,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_SHOW_FLOW,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FLOW_RATE,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_SHOW_FLOW_BLINK,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FLOW_BLINK_RATE,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FLOW_BLINK_START_COLOR,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_FLOW_BLINK_END_COLOR,
        GLS_GLO_SCHEMATICPOLYLINEINTERCONNECT_USE_DISPLAY_LIST,

        // From gls_poly_line.h
        GLS_GLO_POLY_LINE_FIRST_VALUE,
        GLS_GLO_POLY_LINE_THICKNESS,
        GLS_GLO_POLY_LINE_HALO,
        GLS_GLO_POLY_LINE_HALO_COLOR,
        GLS_GLO_POLY_LINE_HALO_THICKNESS,
        GLS_GLO_POLY_LINE_NORMAL,

        // From gls_path_manager.h
        GLS_GLO_PATHMANAGER_FIRST_VALUE,
        GLS_GLO_PATHMANAGER_PATHOBJPAIR_COUNT,
        GLS_GLO_PATHMANAGER_PATHOBJPAIR,

        // From gls_odometer.h
        GLS_GLO_GLSODOMETER_VALUE,
        GLS_GLO_GLSODOMETER_MIN_VALUE,
        GLS_GLO_GLSODOMETER_MAX_VALUE,
        GLS_GLO_GLSODOMETER_BASE_SYSTEM,
        GLS_GLO_GLSODOMETER_BEHAVIOR_TYPE,
        GLS_GLO_GLSODOMETER_GEOMETRY_TYPE,
        GLS_GLO_GLSODOMETER_TEXTURE_SCALE,
        GLS_GLO_GLSODOMETER_DEGREES_PER_DIGIT,
        GLS_GLO_GLSODOMETER_ORDER_OF_MAGNITUDE,
        GLS_GLO_GLSODOMETER_ROLLOVER_THRESHOLD,

        // From gls_nurb_curve.h
        GLS_GLO_GLSNURBCURVE_FIRST_VALUE,
        GLS_GLO_GLSNURBCURVE_EMITEVENT,

        // From gls_nine_patch.h
        GLS_GLO_NINE_PATCH_FIRST_VALUE,
        GLS_GLO_NINE_PATCH_CENTER_VISIBLE,
        GLS_GLO_NINE_PATCH_EDGES,
        GLS_GLO_NINE_PATCH_TEXTURE_EDGES,
        GLS_GLO_NINE_PATCH_RADII,
        GLS_GLO_NINE_PATCH_TEXTURE_POINTS,
        GLS_GLO_NINE_PATCH_COLOR,

        // From serial_morph_mesh.h
        GLS_GLO_SERIAL_MORPH_MESH_KEYFRAME_INDEX,

        // From gls_geometry_resource_mesh.h
        GLS_GLO_GEOMETRY_RESOURCE_MESH_DATA,
        GLS_GLO_GEOMETRY_RESOURCE_MESH_TRANSFORM,
        GLS_GLO_GEOMETRY_RESOURCE_MESH_REFERENCE,
        GLS_GLO_GEOMETRY_RESOURCE_MESH_INDEX_BUF_EFFECTS,

        // From gls_lod_group.h
        GLS_GLO_LOD_GROUP_DISTANCE_RANGE,
        GLS_GLO_LOD_GROUP_LOD_POSITIONS,

        // From gls_text_box.h
        GLS_GLO_TEXT_BOX_VERTICAL_ALIGNMENT,
        GLS_GLO_TEXT_BOX_LEFT_TO_RIGHT,

        // From gls_ctl_text_box.h
        GLS_GLO_CTL_TEXT_BOX_VERTICAL_ALIGNMENT,
        GLS_GLO_CTL_TEXT_BOX_ELLIPSIZE_MODE,
        GLS_GLO_CTL_TEXT_BOX_HORIZONTAL_SCALE,
        GLS_GLO_CTL_TEXT_BOX_VERTICAL_SCALE,
        GLS_GLO_CTL_TEXT_BOX_TEXT_DIRECTION,

        // From gls_linear_float_controller.h
        GLS_GLO_LINEAR_FLOAT_CONTROLLER_KEYARRAY,

        // From gls_moving_eye.h
        GLS_GLO_MOVINGEYE_EMIT_EVENT,
        GLS_GLO_MOVINGEYE_LOOK_AT_OBJECT,
        GLS_GLO_MOVINGEYE_MAX_SPEED,
        GLS_GLO_MOVINGEYE_MOVEMENT,
        GLS_GLO_MOVINGEYE_ROUTE,
        GLS_GLO_MOVINGEYE_DISABLE_HISTORY,

        // From gls_mimic_group.h
        GLS_GLO_MIMIC_GROUP_MIMIC_ACTIVE,
        GLS_GLO_MIMIC_GROUP_AUTO_REDRAW,
        GLS_GLO_MIMIC_GROUP_BOTTOM_LEFT_CORNER,
        GLS_GLO_MIMIC_GROUP_TOP_RIGHT_CORNER,
        GLS_GLO_MIMIC_GROUP_SHOW_OUTLINE,
        GLS_GLO_MIMIC_GROUP_TEXTURE_HEIGHT,
        GLS_GLO_MIMIC_GROUP_TEXTURE_WIDTH,
        GLS_GLO_MIMIC_GROUP_HAS_DEPTH_BUFFER,
        GLS_GLO_MIMIC_GROUP_DEPTH_TEST,
        GLS_GLO_MIMIC_GROUP_GENERATE_MIPMAPS,
        GLS_GLO_MIMIC_GROUP_DRAW_MIMIC_POLYGON,
        GLS_GLO_MIMIC_GROUP_ATTACHED_TEXTURE_INDEX,
        GLS_GLO_MIMIC_GROUP_CLEAR_COLOR,
        GLS_GLO_MIMIC_GROUP_USE_OPAQUE_TEXTURE,

        GLS_GLO_TEXT_SHADOW_OFFSET
    };

    static const unsigned int MAX_STANDARD_ATTR_SIZE = 255;
    static const unsigned int ATTR_SIZE_EXTENDED     = 0;

    struct GloFileHeader
    {
        char          magic[ 4 ];                           // 'GLO\0'
        int           glsMajor;                             // GL Studio major version
        int           glsMinor;                             // GL Studio minor version
        int           glsBuild;                             // GL Studio build version
        unsigned int  numObjects;                           // Number of objects in this file
        unsigned char timestamp[ GLO_FILE_TIMESTAMP_SIZE ]; // Time signature for this file
        char          padding[ 2 ];
    };

    enum
    {
        TEXTURE_PRESENT  = 0x01,
        MATERIAL_PRESENT = 0x02
    };

    struct GloFileFaceArray
    {
        unsigned int  numberOfFaces;     // Number of faces in the array
        int           defaultTexture;    // Default texture for faces if none present in file
        unsigned int  defaultMaterial;   // Default materia for faces if none present in file
        unsigned char indexSize;         // Size of each index in bytes (a,b,c)
        unsigned char textureSize;       // Size of texture index in bytes
        unsigned char materialSize;      // Size of material index in bytes
        unsigned char componentsPresent; // bitfield
                                         //   0x01  Textures present in file
                                         //   0x02  Materials present in file
    };

    /** The current version of the GlsGeometryResourceData. */
    static const int GlsGeometryResourceData_Version = 2;

    struct GlsGeometryResourceDataHeader
    {
        unsigned int version;              // Should be GlsGeometryResourceData_Version
        unsigned int vertexSize;           // Size of a single vertex (in bytes)
        unsigned int numberOfVertices;     // Size of the vertex array
        unsigned int numberOfIndexBuffers; // Number of index buffers

        unsigned char numberOfTextureCoords; // Number of texture coords
        unsigned char numberOfVertexAttribs; // Number of vertex attributes
        bool          hasNormal;
        bool          hasColor;

        bool          hasSecondaryColor;
        bool          hasTangentAttrib;
        unsigned char tangentAttribIndex;
        bool          hasBinormalAttrib;

        unsigned char  binormalAttribIndex;
        unsigned char  padding1;
        unsigned short padding2;

        // The structure is followed by:
        // numberOfVertices vertex data structures (vertexSize*numberOfVertices bytes)
        // numberOfIndexBuffers index buffer arrays
        //   Each index buffer array looks like this
        //     unsigned int size;
        //     <list of unsigned ints (size*4 bytes)>
    };

    // The current version of the GlsGeometryResourceMeshIndexBufEffects
    static const int GlsGeometryResourceMeshIndexBufEffects_Version = 2;

    struct GlsGeometryResourceMeshIndexBufEffectsHeader
    {
        unsigned int version;     // Should be GlsGeometryResourceData_Version
        unsigned int effectCount; // Number of effects

        // The header is followed <effectCount> GlsGeometryResourceMeshIndexBufEffect structures
    };

    struct GlsGeometryResourceMeshIndexBufEffect
    {
        unsigned int materialIndex;
        unsigned int diffuseTextureIndex;
        unsigned int normalTextureIndex;
        unsigned int specularTextureIndex;
        unsigned int reflectionTextureIndex;

        // new for v2
        float diffuseAmount;
        float normalAmount;
        float specularAmount;
        float reflectionAmount;

        bool           useVertexColors;
        bool           normalMapFlipGreen;
        unsigned short padding; // just

        // diffuse UVW settings
        float diffuse_uOffset;
        float diffuse_vOffset;
        float diffuse_uTiling;
        float diffuse_vTiling;
        float diffuse_angle;
        // normal UVW settings
        float normal_uOffset;
        float normal_vOffset;
        float normal_uTiling;
        float normal_vTiling;
        float normal_angle;
        // specular UVW settings
        float specular_uOffset;
        float specular_vOffset;
        float specular_uTiling;
        float specular_vTiling;
        float specular_angle;
    };

    class Writer
    {
    public:
        static const unsigned int MAX_STANDARD_ATTR_SIZE = 255;

        static const unsigned int ATTR_SIZE_EXTENDED = 0;

        // Create a GLO file writer for the given file
        Writer( const std::string& filename, const bool open, const unsigned char* timestamp );

        // Destroy the writer
        ~Writer();

        std::string Filename();

        std::string BaseFilename();

        inline unsigned char* Timestamp() { return _header.timestamp; }

        // Open file and prepare to write
        void OpenForWriting( void );

        void DefaultChecking( bool val ) { _defaultChecking = val; }

        // Start writing an object record
        void StartObjectRecord( void );

        // Add an object attribute to the file for the current object
        void AddObjectAttribute( const unsigned int enumeration, const unsigned int size, const void* data );

        // Methods to add parameters to file
        void AddBoolean( const unsigned int enumerator, const bool value );
        void AddU8( const unsigned int enumerator, const unsigned char value );
        void AddU16( const unsigned int enumerator, const unsigned short value );
        void AddS16( const unsigned int enumerator, const short value );
        void AddU32( const unsigned int enumerator, const unsigned int value );
        void AddS32( const unsigned int enumerator, const int value );
        void AddString( const unsigned int enumerator, const std::string& value );
        void AddCString( const unsigned int enumerator, const char* value );
        void AddFloat( const unsigned int enumerator, const float value );
        void AddDouble( const unsigned int enumerator, const double value );
        void AddVector( const unsigned int enumerator, const Vector& value );
        void AddGlsColor( const unsigned int enumerator, const glsColor& value );
        void AddMatrix( const unsigned int enumerator, const GlsMatrixAffineD& value );
        void AddVertexArray( const unsigned int enumerator, const unsigned int nVertices, const Vertex verts[] );
        void AddVectorArray( const unsigned int enumerator, const unsigned int nVertices, const Vector verts[] );
        void AddFloatArray( const unsigned int enumerator, const unsigned int nVertices, const float verts[] );
        void AddDoubleArray( const unsigned int enumerator, const unsigned int nVertices, const double verts[] );
        void AddMaterialIndices( const unsigned int enumerator, DynamicArray<int>& values );

        // Same as AddVectorArray but only writes X & Y coordinates
        void AddVector2DArray( const unsigned int enumerator, const unsigned int nVertices, const Vector verts[] );

        // Use these to write custom data structures to the file
        unsigned int AddExtendedAttributeHeader( unsigned int enumerator, unsigned int size = 0 );
        unsigned int AddAttributeHeader( unsigned int enumerator, unsigned char size = 0 );

        // Methods to add parameters to file, but check for value = default
        void AddBoolean( const unsigned int enumerator, const bool value, const bool defVal );
        void AddU8( const unsigned int enumerator, const unsigned char value, const unsigned char defVal );
        void AddU16( const unsigned int enumerator, const unsigned short value, const unsigned short defVal );
        void AddS16( const unsigned int enumerator, const short value, const short defVal );
        void AddU32( const unsigned int enumerator, const unsigned int value, const unsigned int defVal );
        void AddS32( const unsigned int enumerator, const int value, const int defVal );
        void AddGlsColor( const unsigned int enumerator, const glsColor& value, const glsColor& defVal );
        void AddFloat( const unsigned int enumerator, const float value, const float defVal );
        void AddDouble( const unsigned int enumerator, const double value, const double defVal );

        // Writes data to file. Doesn't write attribute headers, just writes straight data
        // Data is byte swapped into Big Endian format
        void WriteU8( const unsigned char val );
        void WriteS8( const char val );
        void WriteU16( const unsigned short val );
        void WriteS16( const short val );
        void WriteU32( const unsigned int val );
        void WriteS32( const int val );
        void WriteFloat( const float val );
        void WriteDouble( const double val );
        void WriteGlsColor( const glsColor& value );

        // Writes data to file. Doesn't write attribute headers, just writes straight data
        // Data is byte swapped into Big Endian format.  Writes at the specified offset
        void WriteU8( const unsigned char val, const unsigned int offset );
        void WriteU32( const unsigned int val, const unsigned int offset );

        // Method to add matrix, but only if it isn't identity
        void AddMatrix( const unsigned int enumerator, const GlsMatrixAffineD& value, const bool checkForIdentity );

        // End the current object record
        void EndObjectRecord();

        // Flush the current buffer to disk and rewind
        void Flush();

        // Close the file
        void Close( void );

    protected:
        std::string   _filename;
        bool          _initialized;
        FILE*         _out;
        bool          _defaultChecking;
        unsigned char _timestamp[ GLO_FILE_TIMESTAMP_SIZE ];
        GloFileHeader _header;

        // Current count of the number of objects in the file
        unsigned int _numObjects;

        // Current count of the number of params in the current object
        short _numParams;

        // Byte buffer to store params in
        WriteBuffer* _buffer;

        void WriteFileHeader();
    };

    class Reader
    {
    public:
        /** Do not bother caching GLO files that are larger than 1 MB. */
        static const unsigned int GLO_SIZE_CACHING_LIMIT = 1024 * 1024;

        // Create a GLO file reader for the given file
        Reader( const std::string& filename, const bool open );

        // Destroy the reader
        ~Reader( void );

        // Open file and prepare to read
        bool OpenForReading( void );

        // Get the number of object records in this file
        unsigned int GetNumberOfObjectRecords() { return _header.numObjects; }

        unsigned int GetGLStudioVersionMajor() { return _header.glsMajor; }
        unsigned int GetGLStudioVersionMinor() { return _header.glsMinor; }
        unsigned int GetGLStudioBuildNumber() { return _header.glsBuild; }

        unsigned char* GetTimestamp() { return _header.timestamp; }

        // Close the file
        void Close( void );

        // Data retrieval methods.
        std::string GetString( const unsigned int size )
        {
            std::string retval( _fileDataPointer );
            _fileDataPointer += size;
            return retval;
        }

        bool GetBoolean()
        {
            bool data = false;
            memcpy( &data, _fileDataPointer, sizeof( bool ) );
            _fileDataPointer += sizeof( bool );
            return data;
        }

        char GetByte()
        {
            char data = 0;
            memcpy( &data, _fileDataPointer, sizeof( char ) );
            _fileDataPointer += sizeof( char );
            return data;
        }

        unsigned char GetUnsignedByte()
        {
            unsigned char data = 0u;
            memcpy( &data, _fileDataPointer, sizeof( unsigned char ) );
            _fileDataPointer += sizeof( unsigned char );
            return data;
        }

        short GetShort()
        {
            short data = 0;
            memcpy( &data, _fileDataPointer, sizeof( short ) );
            _fileDataPointer += sizeof( short );
            return data;
        }

        unsigned short GetUnsignedShort()
        {
            unsigned short data = 0u;
            memcpy( &data, _fileDataPointer, sizeof( unsigned short ) );
            _fileDataPointer += sizeof( unsigned short );
            return data;
        }

        int GetInt()
        {
            int data = 0;
            memcpy( &data, _fileDataPointer, sizeof( int ) );
            _fileDataPointer += sizeof( int );
            return data;
        }

        unsigned int GetUnsignedInt()
        {
            unsigned int data = 0u;
            memcpy( &data, _fileDataPointer, sizeof( unsigned int ) );
            _fileDataPointer += sizeof( unsigned int );
            return data;
        }

        float GetFloat()
        {
            float data = 0.0f;
            memcpy( &data, _fileDataPointer, sizeof( float ) );
            _fileDataPointer += sizeof( float );
            return data;
        }

        double GetDouble()
        {
            double data = 0.0;
            memcpy( &data, _fileDataPointer, sizeof( double ) );
            _fileDataPointer += sizeof( double );
            return data;
        }

        void GetBytes( const unsigned int size, char** data )
        {
            memcpy( *data, _fileDataPointer, size );
            _fileDataPointer += size;
        }

        glsColor GetColor()
        {
            glsColor data = glsColor();
            memcpy( &data, _fileDataPointer, sizeof( glsColor ) );
            _fileDataPointer += sizeof( glsColor );
            return data;
        }

        DynamicArray<int> GetMaterialIndices()
        {
            DynamicArray<int> returnVal;
            unsigned int      count = (unsigned int)GetInt();
            for( unsigned int i = 0; i < count; i++ )
            {
                returnVal.InsertObject( GetInt() );
            }
            return returnVal;
        }

        bool IsInitialized() { return _initialized; }

        const std::string& GetFilename() { return _filename; }

    protected:
        std::string   _filename;
        bool          _initialized;
        FILE*         _in;
        unsigned int  _numberOfObjectRecords;
        unsigned int  _glsMajor;
        unsigned int  _glsMinor;
        unsigned int  _glsBuild;
        unsigned char _timestamp[ GLO_FILE_TIMESTAMP_SIZE ];
        GloFileHeader _header;
        char*         _fileData;
        const char*   _fileDataPointer;
    };

    class WriteBuffer
    {
    public:
        WriteBuffer( const unsigned int initialSize );

        ~WriteBuffer();

        // Ensure the buffer is at least the specified size
        void Resize( const unsigned int minimumSize );

        // Enlarge buffer by at least incrementalSize
        void Enlarge( const unsigned int incrementalSize );

        // Get the buffer pointer
        unsigned char* Buffer();

        // Get the current buffer size
        unsigned int Size();

        // Write data to the buffer at the current offset, moving the
        // current write position
        void WriteData( const void* data, const unsigned int size );

        // Write data to the buffer at a specific offset, not moving the
        // current write position
        void WriteData( const void* data, const unsigned int size, const unsigned int offset );

        // Rewind to beginning of buffer
        void Rewind();

    protected:
        // Total size of the params for the current object
        unsigned int _current;

        // Size of the param buffer
        unsigned int _bufSize;

        // Buffer containing the params for the current object
        unsigned char* _buf;
    };

    class ObjectData
    {
    public:
        ObjectData( Reader* reader );

        ~ObjectData();

        void SetNumAttributes( const short numAttributes )
        {
            _numAttributes = numAttributes;
        }

        bool HasAttributes()
        {
            return ( _numAttributes > 0 );
        }

        GlsGloFileAttribute* GetNextAttribute();

    private:
        Reader*              _reader;
        short                _numAttributes;
        GlsGloFileAttribute* _glsGloFileAttribute;
    };

    // constructor - throws GlsGloFileNotFoundException if glow file isn't found.
    GLSGEN_GlsGloFile_EXPORT GlsGloFile( const std::string& filename, const bool readMode = true );
    GLSGEN_GlsGloFile_EXPORT ~GlsGloFile();
    ObjectData*                   GetNextObject();
    GLSGEN_GlsGloFile_EXPORT void VerifyTimestamp( const unsigned char* timestamp, const char* className );

protected:
    Reader*     _reader;
    int         _numObjectsRemaining;
    ObjectData* _objectData;

    // Stores the name of the file that we're reading; currently only used to make the error
    // messages more intelligent.
    std::string _filename;
};

class GlsGloFileAttribute
{
public:
    GlsGloFileAttribute( GlsGloFile::Reader* reader )
        : _reader( reader )
        , _enumeration( 0 )
        , _size( 0 )
    {
    }

    ~GlsGloFileAttribute()
    {
    }

    void SetEnumeration( const unsigned int enumeration )
    {
        _enumeration = enumeration;
    }

    void SetSize( const unsigned int size )
    {
        _size = size;
    }

    // Data Retrieval Methods
    unsigned int Enumeration()
    {
        return _enumeration;
    }
    unsigned int Size()
    {
        return _size;
    }

    std::string GetString()
    {
        return _reader->GetString( _size );
    }

    void GetVector( Vector& rval )
    {
        rval.x = _reader->GetFloat();
        rval.y = _reader->GetFloat();
        rval.z = _reader->GetFloat();
    }
    void GetVertex( Vertex& rval )
    {
        rval.x = _reader->GetFloat();
        rval.y = _reader->GetFloat();
        rval.z = _reader->GetFloat();
        rval.color.R( _reader->GetUnsignedByte() );
        rval.color.G( _reader->GetUnsignedByte() );
        rval.color.B( _reader->GetUnsignedByte() );
        rval.color.A( _reader->GetUnsignedByte() );
    }

    glsColor GetColor()
    {
        return _reader->GetColor();
    }

    void GetColor( glsColor& rval )
    {
        // Call the assignment version of this overload.
        rval = GetColor();
    }

    bool GetBoolean()
    {
        return _reader->GetBoolean();
    }

    char GetByte()
    {
        return _reader->GetByte();
    }

    unsigned char GetUnsignedByte()
    {
        return _reader->GetUnsignedByte();
    }

    short GetShort()
    {
        return _reader->GetShort();
    }

    unsigned short GetUnsignedShort()
    {
        return _reader->GetUnsignedShort();
    }

    int GetInt()
    {
        return _reader->GetInt();
    }

    unsigned int GetUnsignedInt()
    {
        return _reader->GetUnsignedInt();
    }

    float GetFloat()
    {
        return _reader->GetFloat();
    }

    double GetDouble()
    {
        return _reader->GetDouble();
    }

    char* GetBytes()
    {
        char* rval = new char[ _size ];
        _reader->GetBytes( _size, &rval );
        return rval;
    }

    DynamicArray<int> GetMaterialIndices()
    {
        return _reader->GetMaterialIndices();
    }

    void GetBytes( const unsigned int size, void* data )
    {
        _reader->GetBytes( size, (char**)&data );
    }

private:
    GlsGloFile::Reader* _reader;
    unsigned int        _enumeration;
    unsigned int        _size;
};

// Byte swapping functions used by this class.
float          SwapFloatToNet( float val );
double         SwapDoubleToNet( double val );
unsigned int   SwapLongToNet( unsigned int val );
unsigned int   SwapSignedLongToNet( int val );
unsigned short SwapShortToNet( unsigned short val );
short          SwapSignedShortToNet( short val );

} // namespace disti

#endif