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;
 
/// Convert a float into network order (big endian).
/// \param val The value to convert.
/// \return The converted value.
float SwapFloatToNet( float val );
 
/// Convert a double into network order (big endian).
/// \param val The value to convert.
/// \return The converted value.
double SwapDoubleToNet( double val );
 
/// Convert an unsigned integer into network order (big endian).
/// \param val The value to convert.
/// \return The converted value.
unsigned int SwapLongToNet( unsigned int val );
 
/// Convert a signed integer into network order (big endian).
/// \param val The value to convert.
/// \return The converted value.
unsigned int SwapSignedLongToNet( int val );
 
/// Convert a unsigned short into network order (big endian).
/// \param val The value to convert.
/// \return The converted value.
unsigned short SwapShortToNet( unsigned short val );
 
/// Convert a signed short into network order (big endian).
/// \param val The value to convert.
/// \return The converted value.
short SwapSignedShortToNet( short val );
 
// Exception thrown from GlsGloFile contstructor
class GLSGEN_GlsGloFile_EXPORT GlsGloFileNotFoundException
{
};
 
/// \details The GlsGloFile class. Handles storage of GLS property values outside of the generated code. (ES only)
class GlsGloFile
{
public:
    // Forward declarations.
    class WriteBuffer;
 
    static const unsigned int NUM_OBJECTS_OFFSET = 16; ///< The size of the GLO file header in bytes.
 
    /** 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,
        GLS_GLO_TEXT_BOX_RESIZE_MODE,
        GLS_GLO_TEXT_BOX_MAX_WIDTH,
        GLS_GLO_TEXT_BOX_MAX_HEIGHT,
 
        // 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,
        GLS_GLO_CTL_TEXT_BOX_RESIZE_MODE,
        GLS_GLO_CTL_TEXT_BOX_MAX_WIDTH,
        GLS_GLO_CTL_TEXT_BOX_MAX_HEIGHT,
 
        // 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; ///< Maximum size for a standard attribute, extended attributes beyond this size.
    static const unsigned int ATTR_SIZE_EXTENDED     = 0;   ///< Value to indicate that a size is extended.
 
    /// \details The GloFileHeader struct. Contains version and timestamp information.
    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 ];                         ///< Padding.
    };
 
    enum
    {
        TEXTURE_PRESENT  = 0x01,
        MATERIAL_PRESENT = 0x02
    };
 
    /// \details The GloFileFaceArray struct. Contains information for mesh objects.
    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;
 
    /// \details The GlsGeometryResourceDataHeader struct. Contains header information for mesh objects.
    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;             ///< If true, geometry has normals.
        bool          hasColor;              ///< If true, geometry has color information.
 
        bool          hasSecondaryColor;  ///< If true, geometry has secondary color information.
        bool          hasTangentAttrib;   ///< If true, geometry has tangent attribute.
        unsigned char tangentAttribIndex; ///< Index of the tangent attribute.
        bool          hasBinormalAttrib;  ///< If true, geometry has binormal attribute.
 
        unsigned char  binormalAttribIndex; ///< Index of the binormal attribute.
        unsigned char  padding1;            ///< Padding.
        unsigned short padding2;            ///< Padding.
 
        // 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)>
    };
 
    static const int GlsGeometryResourceMeshIndexBufEffects_Version = 2; ///< The current version of the GlsGeometryResourceMeshIndexBufEffects.
 
    /// \details The GlsGeometryResourceMeshIndexBufEffectsHeader struct. Contains version and number of effects.
    struct GlsGeometryResourceMeshIndexBufEffectsHeader
    {
        unsigned int version;     ///< Should be GlsGeometryResourceData_Version
        unsigned int effectCount; ///< Number of effects
 
        // The header is followed <effectCount> GlsGeometryResourceMeshIndexBufEffect structures
    };
 
    /// \details The GlsGeometryResourceMeshIndexBufEffect struct. Contains material information for mesh objects.
    struct GlsGeometryResourceMeshIndexBufEffect
    {
        unsigned int materialIndex;          ///< Material index to be used.
        unsigned int diffuseTextureIndex;    ///< Texture index for diffuse color.
        unsigned int normalTextureIndex;     ///< Texture index for normal map.
        unsigned int specularTextureIndex;   ///< Texture index for specular map.
        unsigned int reflectionTextureIndex; ///< Texture index for reflection map.
 
        // new for v2
        float diffuseAmount;    ///< Intensity of diffuse color from 0.0 to 1.0.
        float normalAmount;     ///< Intensity of normal map from 0.0 to 1.0.
        float specularAmount;   ///< Intensity of specular map from 0.0 to 1.0.
        float reflectionAmount; ///< Intensity of reflection map from 0.0 to 1.0.
 
        bool           useVertexColors;    ///< If true, will use vertex colors rather than material color.
        bool           normalMapFlipGreen; ///< If true will flip the green channel for normals (DirectX versus OpenGL style normals).
        unsigned short padding;            ///< Padding.
 
        // diffuse UVW settings
        float diffuse_uOffset; ///< Diffuse texture U coordinate offset.
        float diffuse_vOffset; ///< Diffuse texture V coordinate offset.
        float diffuse_uTiling; ///< Diffuse texture U coordinate scale.
        float diffuse_vTiling; ///< Diffuse texture V coordinate offset.
        float diffuse_angle;   ///< Diffuse texture rotation angle in degrees.
        // normal UVW settings
        float normal_uOffset; ///< Normal texture U coordinate offset.
        float normal_vOffset; ///< Normal texture V coordinate offset.
        float normal_uTiling; ///< Normal texture U coordinate scale.
        float normal_vTiling; ///< Normal texture V coordinate offset.
        float normal_angle;   ///< Normal texture rotation angle in degrees.
        // specular UVW settings
        float specular_uOffset; ///< Specular texture U coordinate offset.
        float specular_vOffset; ///< Specular texture V coordinate offset.
        float specular_uTiling; ///< Specular texture U coordinate scale.
        float specular_vTiling; ///< Specular texture V coordinate offset.
        float specular_angle;   ///< Specular texture rotation angle in degrees.
    };
 
    /// \details The Writer class. Handles output of GLS property values to the GLO file format.
    class Writer
    {
    public:
        static const unsigned int MAX_STANDARD_ATTR_SIZE = 255; ///< Maximum size for a standard attribute, extended attributes beyond this size.
        static const unsigned int ATTR_SIZE_EXTENDED     = 0;   ///< Value to indicate that a size is extended.
 
        /// Create a GLO file writer for the given file
        /// \param filename The filename to write the GLO file to.
        /// \param open If true, open the file on construction.
        /// \param timestamp The timestamp to write to the file.
        Writer( const std::string& filename, const bool open, const unsigned char* timestamp );
 
        // Destroy the writer
        ~Writer();
 
        /// \return The full file path to the GLO file.
        std::string Filename();
 
        /// \return The file name component of the GLO file.
        std::string BaseFilename();
 
        /// \return The timestamp to be written to the file.
        inline unsigned char* Timestamp() { return _header.timestamp; }
 
        /// Open file and prepare to write.
        void OpenForWriting();
 
        /// If true, values will be written to the GLO file only if they are different from the default value.
        /// \param val The new default checking flag to set.
        void DefaultChecking( bool val ) { _defaultChecking = val; }
 
        /// Start writing an object record.
        void StartObjectRecord();
 
        /// Add an object attribute to the file for the current object.
        /// \param enumeration Identifier for this attribute.
        /// \param size The size to be written in bytes.
        /// \param data The data to be written.
        void AddObjectAttribute( const unsigned int enumeration, const unsigned int size, const void* data );
 
        // Methods to add parameters to file
 
        /// Write a boolean value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddBoolean( const unsigned int enumerator, const bool value );
 
        /// Write an unsigned 8 bit value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddU8( const unsigned int enumerator, const unsigned char value );
 
        /// Write an unsigned 16 bit value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddU16( const unsigned int enumerator, const unsigned short value );
 
        /// Write a signed 16 bit value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddS16( const unsigned int enumerator, const short value );
 
        /// Write an unsigned 32 bit value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddU32( const unsigned int enumerator, const unsigned int value );
 
        /// Write a signed 32 bit value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddS32( const unsigned int enumerator, const int value );
 
        /// Write a std::string value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddString( const unsigned int enumerator, const std::string& value );
 
        /// Write a C string value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddCString( const unsigned int enumerator, const char* value );
 
        /// Write a float value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddFloat( const unsigned int enumerator, const float value );
 
        /// Write a double value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddDouble( const unsigned int enumerator, const double value );
 
        /// Write a Vector value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddVector( const unsigned int enumerator, const Vector& value );
 
        /// Write a color value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddGlsColor( const unsigned int enumerator, const glsColor& value );
 
        /// Write a 4x4 matrix value to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        void AddMatrix( const unsigned int enumerator, const GlsMatrixAffineD& value );
 
        /// Write a list of vertices to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param nVertices The number of vertices to write.
        /// \param verts A list containing the vertices to write.
        void AddVertexArray( const unsigned int enumerator, const unsigned int nVertices, const Vertex verts[] );
 
        /// Write a list of vectors to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param nVertices The number of vectors to write.
        /// \param verts A list containing the vectors to write.
        void AddVectorArray( const unsigned int enumerator, const unsigned int nVertices, const Vector verts[] );
 
        /// Write a list of floats to the GLO file.
        /// \param enumerator the identifier for this attribute
        /// \param nVertices the number of floats to write
        /// \param verts a list containing the floats to write
        void AddFloatArray( const unsigned int enumerator, const unsigned int nVertices, const float verts[] );
 
        /// Write a list of doubles to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param nVertices The number of doubles to write.
        /// \param verts A list containing the doubles to write.
        void AddDoubleArray( const unsigned int enumerator, const unsigned int nVertices, const double verts[] );
 
        /// Write a list of material indices to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param values The material indices list to write.
        void AddMaterialIndices( const unsigned int enumerator, DynamicArray<int>& values );
 
        /// Same as AddVectorArray but only writes X & Y coordinates
        /// \param enumerator The identifier for this attribute.
        /// \param nVertices The number of vectors to write.
        /// \param verts A list containing the vectors to write.
        void AddVector2DArray( const unsigned int enumerator, const unsigned int nVertices, const Vector verts[] );
 
        /// Use these to write custom data structures to the file.
        /// Can write structures larger than 255 bytes to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param size The size of this attribute.
        /// \return offset Of extended size for later to allow caller to modify size.
        unsigned int AddExtendedAttributeHeader( unsigned int enumerator, unsigned int size = 0 );
 
        /// Write a standard header to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param size The size of this attribute.
        /// \return offset Of extended size for later to allow caller to modify size.
        unsigned int AddAttributeHeader( unsigned int enumerator, unsigned char size = 0 );
 
        /// Same as AddBoolean(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddBoolean( const unsigned int enumerator, const bool value, const bool defVal );
 
        /// Same as AddU8(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddU8( const unsigned int enumerator, const unsigned char value, const unsigned char defVal );
 
        /// Same as AddU16(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddU16( const unsigned int enumerator, const unsigned short value, const unsigned short defVal );
 
        /// Same as AddS16(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddS16( const unsigned int enumerator, const short value, const short defVal );
 
        /// Same as AddU32(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddU32( const unsigned int enumerator, const unsigned int value, const unsigned int defVal );
 
        /// Same as AddS32(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddS32( const unsigned int enumerator, const int value, const int defVal );
 
        /// Same as AddGlsColor(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddGlsColor( const unsigned int enumerator, const glsColor& value, const glsColor& defVal );
 
        /// Same as AddFloat(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddFloat( const unsigned int enumerator, const float value, const float defVal );
 
        /// Same as AddDouble(), but check against the default value, unless _defaultChecking is false.
        /// If the value matches the default value, it will not be written to the GLO file.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param defVal The default value for this attribute.
        void AddDouble( const unsigned int enumerator, const double value, const double defVal );
 
        /// Write an unsigned 8 bit value directly to the GLO file.
        /// \param val The value to write.
        void WriteU8( const unsigned char val );
 
        /// Write a signed 8 bit value directly to the GLO file.
        /// \param val The value to write.
        void WriteS8( const char val );
 
        /// Write an unsigned 16 bit value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        void WriteU16( const unsigned short val );
 
        /// Write a signed 16 bit value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        void WriteS16( const short val );
 
        /// Write an unsigned 32 bit value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        void WriteU32( const unsigned int val );
 
        /// Write a signed 32 bit value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        void WriteS32( const int val );
 
        /// Write a float value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        void WriteFloat( const float val );
 
        /// Write a double value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        void WriteDouble( const double val );
 
        /// Write a color value directly to the GLO file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param value The value to write.
        void WriteGlsColor( const glsColor& value );
 
        /// Write an unsigned 8 bit value directly to the GLO file.
        /// Writes at the specified offset into the file.
        /// \param val The value to write.
        /// \param offset The offset at which to write the value.
        void WriteU8( const unsigned char val, const unsigned int offset );
 
        /// Write an unsigned 8 bit value directly to the GLO file.
        /// Writes at the specified offset into the file.
        /// \note Data is byte swapped into Big Endian format.
        /// \param val The value to write.
        /// \param offset The offset at which to write the value.
        void WriteU32( const unsigned int val, const unsigned int offset );
 
        /// Method to add matrix, but only if it isn't identity.
        /// \param enumerator The identifier for this attribute.
        /// \param value The value for this attribute.
        /// \param checkForIdentity If true, will check for identify before writing to file.
        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();
 
    protected:
        std::string   _filename;                             ///< The file name of the GLO file to write.
        bool          _initialized;                          ///< If true, the file is ready for writing.
        FILE*         _out;                                  ///< The OS file handle to the file to be written.
        bool          _defaultChecking;                      ///< If true, will not write values to file that match default values.
        unsigned char _timestamp[ GLO_FILE_TIMESTAMP_SIZE ]; ///< Storage for the file generation timestamp.
        GloFileHeader _header;                               ///< File header information to be written to the file.
        unsigned int  _numObjects;                           ///< Current count of the number of objects in the file.
        short         _numParams;                            ///< Current count of the number of params in the current object.
        WriteBuffer*  _buffer;                               ///< Byte buffer to store params in.
 
        /// Writes the file header data to the GLO file.
        void WriteFileHeader();
    };
 
    /// \details The Reader class. Handles input of GLS property values from the GLO file format to the application.
    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.
        /// \param filename The file name to read from.
        /// \param open If true, the file will be opened on construction.
        Reader( const std::string& filename, const bool open );
 
        /// Destroy the reader.
        ~Reader();
 
        /// Open file and prepare to read.
        /// \return True if the operation was successful.
        bool OpenForReading();
 
        /// \return The number of object records in this file.
        unsigned int GetNumberOfObjectRecords() { return _header.numObjects; }
 
        /// \return The major version of the editor that generated this file.
        unsigned int GetGLStudioVersionMajor() { return _header.glsMajor; }
 
        /// \return The minor version of the editor that generated this file.
        unsigned int GetGLStudioVersionMinor() { return _header.glsMinor; }
 
        /// \return The build version of the editor that generated this file.
        unsigned int GetGLStudioBuildNumber() { return _header.glsBuild; }
 
        /// \return The timestamp of this file's creation.
        unsigned char* GetTimestamp() { return _header.timestamp; }
 
        /// Close the file.
        void Close();
 
        /// Read a string of the specified size from the file.
        /// \param size The length in bytes to read.
        /// \return The string that was read.
        std::string GetString( const unsigned int size )
        {
            std::string retval( _fileDataPointer );
            _fileDataPointer += size;
            return retval;
        }
 
        /// \return A boolean value read from the GLO file.
        bool GetBoolean()
        {
            bool data = false;
            memcpy( &data, _fileDataPointer, sizeof( bool ) );
            _fileDataPointer += sizeof( bool );
            return data;
        }
 
        /// \return A single byte read from the GLO file.
        char GetByte()
        {
            char data = 0;
            memcpy( &data, _fileDataPointer, sizeof( char ) );
            _fileDataPointer += sizeof( char );
            return data;
        }
 
        /// \return A single unsigned byte read from the GLO file.
        unsigned char GetUnsignedByte()
        {
            unsigned char data = 0u;
            memcpy( &data, _fileDataPointer, sizeof( unsigned char ) );
            _fileDataPointer += sizeof( unsigned char );
            return data;
        }
 
        /// \return A short read from the GLO file.
        short GetShort()
        {
            short data = 0;
            memcpy( &data, _fileDataPointer, sizeof( short ) );
            _fileDataPointer += sizeof( short );
            return data;
        }
 
        /// \return An unsigned short read from the GLO file.
        unsigned short GetUnsignedShort()
        {
            unsigned short data = 0u;
            memcpy( &data, _fileDataPointer, sizeof( unsigned short ) );
            _fileDataPointer += sizeof( unsigned short );
            return data;
        }
 
        /// \return An int read from the GLO file.
        int GetInt()
        {
            int data = 0;
            memcpy( &data, _fileDataPointer, sizeof( int ) );
            _fileDataPointer += sizeof( int );
            return data;
        }
 
        /// \return An unsigned int read from the GLO file.
        unsigned int GetUnsignedInt()
        {
            unsigned int data = 0u;
            memcpy( &data, _fileDataPointer, sizeof( unsigned int ) );
            _fileDataPointer += sizeof( unsigned int );
            return data;
        }
 
        /// \return A float read from the GLO file.
        float GetFloat()
        {
            float data = 0.0f;
            memcpy( &data, _fileDataPointer, sizeof( float ) );
            _fileDataPointer += sizeof( float );
            return data;
        }
 
        /// \return A double read from the GLO file.
        double GetDouble()
        {
            double data = 0.0;
            memcpy( &data, _fileDataPointer, sizeof( double ) );
            _fileDataPointer += sizeof( double );
            return data;
        }
 
        /// Read the specified number of bytes from the GLO file.
        /// \param size The number of bytes to read.
        /// \param data A pointer to a valid memory region where the bytes will be copied.
        void GetBytes( const unsigned int size, char** data )
        {
            memcpy( *data, _fileDataPointer, size );
            _fileDataPointer += size;
        }
 
        /// \return A color read from the GLO file.
        glsColor GetColor()
        {
            glsColor data = glsColor();
            memcpy( &data, _fileDataPointer, sizeof( glsColor ) );
            _fileDataPointer += sizeof( glsColor );
            return data;
        }
 
        /// \return A list of material indices read from the GLO file.
        DynamicArray<int> GetMaterialIndices()
        {
            unsigned int      count = (unsigned int)GetInt();
            DynamicArray<int> materialIndices( count );
            for( unsigned int i = 0; i < count; i++ )
            {
                materialIndices.PushBack( GetInt() );
            }
            return materialIndices;
        }
 
        /// \return True if the file is ready to be read.
        bool IsInitialized() { return _initialized; }
 
        /// \return The file name of this GLO file.
        const std::string& GetFilename() { return _filename; }
 
    protected:
        std::string   _filename;                             ///< The file name of this GLO file.
        bool          _initialized;                          ///< If true, the file is ready for reading.
        FILE*         _in;                                   ///< The OS file handle for this GLO file.
        unsigned int  _numberOfObjectRecords;                ///< The number of objects described by this GLO file.
        unsigned int  _glsMajor;                             ///< The major version of GL Studio that generated this GLO file.
        unsigned int  _glsMinor;                             ///< The minor version of GL Studio that generated this GLO file.
        unsigned int  _glsBuild;                             ///< The build version of GL Studio that generated this GLO file.
        unsigned char _timestamp[ GLO_FILE_TIMESTAMP_SIZE ]; ///< The timestamp when this file was generated.
        GloFileHeader _header;                               ///< The parsed file header data.
        char*         _fileData;                             ///< Pointer holding the all data read in.
        const char*   _fileDataPointer;                      ///< Current read position within the GLO data.
    };
 
    /// \details The WriteBuffer class. A resizable binary stream.
    class WriteBuffer
    {
    public:
        /// Constructor
        /// \param initialSize The initial size of the buffer in bytes.
        WriteBuffer( const unsigned int initialSize );
 
        ~WriteBuffer();
 
        /// Ensure the buffer is at least the specified size.
        /// \param minimumSize The minimum size in bytes.
        void Resize( const unsigned int minimumSize );
 
        /// Enlarge buffer by at least incrementalSize
        /// \param incrementalSize Increase by this size in bytes.
        void Enlarge( const unsigned int incrementalSize );
 
        /// \return The buffer pointer.
        unsigned char* Buffer();
 
        /// \return The current buffer size.
        unsigned int Size();
 
        /// Write data to the buffer at the current offset, moving the current write position.
        /// \param data Pointer to the data to write.
        /// \param size The number of bytes to write.
        void WriteData( const void* data, const unsigned int size );
 
        /// Write data to the buffer at a specific offset, not moving the current write position.
        /// \param data Pointer to the data to write.
        /// \param size The number of bytes to write.
        /// \param offset The position in the buffer to write to.
        void WriteData( const void* data, const unsigned int size, const unsigned int offset );
 
        /// Rewind to beginning of buffer.
        void Rewind();
 
    protected:
        unsigned int   _current; ///< Total size of the params for the current object.
        unsigned int   _bufSize; ///< Size of the param buffer.
        unsigned char* _buf;     ///< Buffer containing the params for the current object.
    };
 
    /// \details The ObjectData class. A wrapper used to iterate through GLO data.
    class ObjectData
    {
    public:
        /// Constructor
        /// \param reader Observing pointer to the GLO reader.
        ObjectData( Reader* reader );
 
        ~ObjectData();
 
        /// Set the number of attributes to be read
        /// \param numAttributes The new number of attributes to be read.
        void SetNumAttributes( const short numAttributes ) { _numAttributes = numAttributes; }
 
        /// \return Whether or not there are any attributes to be read.
        bool HasAttributes() { return ( _numAttributes > 0 ); }
 
        /// \return A pointer to the next attribute to be read.
        GlsGloFileAttribute* GetNextAttribute();
 
    private:
        Reader*              _reader;              ///< Observing pointer to the file reader.
        short                _numAttributes;       ///< The total number of attributes to read.
        GlsGloFileAttribute* _glsGloFileAttribute; ///< Observing pointer to the current attribute.
    };
 
    /// Constructor - throws GlsGloFileNotFoundException if glow file isn't found.
    /// \param filename Name of the GLO file to load.
    /// \param readMode If true, will read the file on construction.
    GLSGEN_GlsGloFile_EXPORT GlsGloFile( const std::string& filename, const bool readMode = true );
 
    GLSGEN_GlsGloFile_EXPORT ~GlsGloFile();
 
    /// \return A pointer to the next object to read in.
    ObjectData* GetNextObject();
 
    /// Check the timestamp of the GLO file against the generated source.
    /// A warning will be emitted if they do not match, as this could cause inconsistencies.
    /// \param timestamp The timestamp value to compare.
    /// \param className The generated source class name whose timestamp is being compared.
    GLSGEN_GlsGloFile_EXPORT void VerifyTimestamp( const unsigned char* timestamp, const char* className );
 
protected:
    Reader*     _reader;              ///< Observing pointer to the file reader.
    int         _numObjectsRemaining; ///< Number of objects remaining to read.
    ObjectData* _objectData;          ///< Observing pointer to the current data.
 
    std::string _filename; ///< Stores the name of the file that we're reading; currently only used to make the error messages more intelligent.
};
 
/// \details The GlsGloFileAttribute class. A wrapper between the binary format and the application.
class GlsGloFileAttribute
{
public:
    /// Constructor
    /// \param reader An observing pointer to the GLO file reader.
    GlsGloFileAttribute( GlsGloFile::Reader* reader )
        : _reader( reader )
        , _enumeration( 0 )
        , _size( 0 )
    {
    }
 
    ~GlsGloFileAttribute()
    {
    }
 
    /// Set the type of this attribute.
    /// \param enumeration The attribute type to set.
    void SetEnumeration( const unsigned int enumeration )
    {
        _enumeration = enumeration;
    }
 
    /// Set the size of this attribute in bytes.
    /// \param size The new size to set.
    void SetSize( const unsigned int size )
    {
        _size = size;
    }
 
    /// \return The attribute type.
    unsigned int Enumeration()
    {
        return _enumeration;
    }
 
    /// \return The attribute size in bytes.
    unsigned int Size()
    {
        return _size;
    }
 
    /// \return The underlying string based on the size of the attribute.
    std::string GetString()
    {
        return _reader->GetString( _size );
    }
 
    /// Get the underlying Vector object.
    /// \param rval The returned underlying vector.
    void GetVector( Vector& rval )
    {
        rval.x = _reader->GetFloat();
        rval.y = _reader->GetFloat();
        rval.z = _reader->GetFloat();
    }
 
    /// Get the underlying Vertex object.
    /// \param rval The returned underlying vertex.
    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() );
    }
 
    /// \return The underlying color value.
    glsColor GetColor()
    {
        return _reader->GetColor();
    }
 
    /// Get the underlying Color value.
    /// \param rval The returned underlying color.
    void GetColor( glsColor& rval )
    {
        // Call the assignment version of this overload.
        rval = GetColor();
    }
 
    /// \return The underlying boolean value.
    bool GetBoolean()
    {
        return _reader->GetBoolean();
    }
 
    /// \return The underlying byte value.
    char GetByte()
    {
        return _reader->GetByte();
    }
 
    /// \return The underlying unsigned byte value.
    unsigned char GetUnsignedByte()
    {
        return _reader->GetUnsignedByte();
    }
 
    /// \return The underlying short value.
    short GetShort()
    {
        return _reader->GetShort();
    }
 
    /// \return The underlying unsigned short value.
    unsigned short GetUnsignedShort()
    {
        return _reader->GetUnsignedShort();
    }
 
    /// \return The underlying int value.
    int GetInt()
    {
        return _reader->GetInt();
    }
 
    /// \return The underlying unsigned int value.
    unsigned int GetUnsignedInt()
    {
        return _reader->GetUnsignedInt();
    }
 
    /// \return The underlying float value.
    float GetFloat()
    {
        return _reader->GetFloat();
    }
 
    /// \return The underlying double value.
    double GetDouble()
    {
        return _reader->GetDouble();
    }
 
    /// \return The underlying C string value based on the size of the attribute.
    char* GetBytes()
    {
        char* rval = new char[ _size ];
        _reader->GetBytes( _size, &rval );
        return rval;
    }
 
    /// \return The underlying material indices list.
    DynamicArray<int> GetMaterialIndices()
    {
        return _reader->GetMaterialIndices();
    }
 
    /// Get the underlying C string value.
    /// \param size The size of the attribute.
    /// \param data A pointer to a valid memory region where the string will be copied.
    void GetBytes( const unsigned int size, void* data )
    {
        _reader->GetBytes( size, (char**)&data );
    }
 
private:
    GlsGloFile::Reader* _reader;      ///< Observing pointer to the GLO file reader.
    unsigned int        _enumeration; ///< The type of this attribute.
    unsigned int        _size;        ///< The size of this attribute.
};
 
} // namespace disti
 
#endif