hps.h

// Copyright (c) Tech Soft 3D, Inc.
//
// The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
// and considered a trade secret as defined under civil and criminal statutes.
// Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
// unauthorized use or misappropriation of its trade secrets.  Use of this information
// by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
// a written non-disclosure agreement, expressly prescribing the scope and manner of such use.

#ifndef HPS_H
#define HPS_H

#ifdef _MSC_VER
#   ifndef STATIC_APP
#       ifdef HPS_CORE_BUILD
#           define HPS_API __declspec (dllexport)
#           define EXPIMP_TEMPLATE
#       else
#           define HPS_API __declspec (dllimport)
#           define EXPIMP_TEMPLATE extern
#       endif
#       define HPS_TEMPLATE_API __declspec (dllexport)
#   endif
#   ifdef _WINDOWS_
#       undef Ellipse
#       undef Polyline
#       undef Polygon
#       undef Rectangle
#       undef min
#       undef max
#   endif
#   pragma warning(push)
#   pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
#else
#   include <limits.h>
#   include <stddef.h>
#   ifdef LINUX_SYSTEM
#       ifndef STATIC_APP
#           ifdef HPS_CORE_BUILD
#               define HPS_API __attribute__ ((visibility ("default")))
#               define EXPIMP_TEMPLATE
#           else
#               define EXPIMP_TEMPLATE extern
#           endif
#           define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
#       endif
#   endif
#endif
#ifndef HPS_API
#   define HPS_API
#endif
#ifndef HPS_TEMPLATE_API
#   define HPS_TEMPLATE_API
#endif
#ifndef EXPIMP_TEMPLATE
#   define EXPIMP_TEMPLATE
#endif
#ifndef ENUM_CLASS
#   define ENUM_CLASS enum class
#endif

#define NO_HPS_API

#include <stdint.h>
#include <memory>
#include <vector>
#include <math.h>
#include <float.h>
#include <limits>
#include <stdexcept>
#include <algorithm>
#include <cstring>


namespace HPSI
{
    class Impl;
    class KeyImpl;
    class TicketImpl;
    class EventDispatcherImpl;
    class AbstractImage;
    class String;
};

namespace HPS
{

    // unimplemented


//Begin Info
class HPS_API Info
{
public:

    enum class Code : uint32_t
    {
        Unknown,            
        Exchange,           
        Publish,            
        Data,               
        Key,                
        Geometry,           
        Database,           
        Driver,             
        Internal,           
        Memory,             
        System,             
        Unsupported,        
        DWG,                
        Parasolid,          
    };

private:
    Info() {}
};


//Begin Info
class HPS_API Emergency
{
public:

    enum class Code : uint32_t
    {
        Unknown,            
        Fatal,              
        SoftMemoryLimit,    
        HardMemoryLimit,    
    };

private:
    Emergency() {}
};


//Begin Window
class HPS_API Window
{
public:

    enum class Driver : uint32_t
    {
        Default3D,          
        OpenGL,             
        OpenGL2,            
        DirectX11,          
        OpenGL1Deprecated,  
        Vulkan,
        OpenGL2Mesa,
    };

    enum class UpdateStatus : uint32_t
    {
        InProgress,         
        Completed,          
        TimedOut,           
        Interrupted,        
        Failed              
    };

    enum class UpdateType : uint32_t
    {
        Default,

        Complete,

        Refresh,
        
        CompileOnly,

        Exhaustive,
    };

    enum class Mobility : uint32_t
    {
        Locked,             
        Floating,           
        FixedRatio,         
        Free                
    };

    enum class FrameSize : uint32_t
    {
        Single,             
        Double              
    };

    enum class FrameOptions : uint32_t
    {
        Inset,              
        Overlay             
    };

    enum class ImageFormat : uint32_t
    {
        Default,            
        RGBA,               
        RGB,                
        Jpeg,               
        Png                 
    };

private:
    Window() {}
};

//Begin Subwindow
class HPS_API Subwindow
{
public:
    enum class Background : uint32_t
    {
        SolidColor,                     
        Image,                          
        Cubemap,                        
        Blend,                          
        Transparent,                    
        Interactive,                    

        GradientTopToBottom,            
        GradientBottomToTop,            
        GradientLeftToRight,            
        GradientRightToLeft,            
        GradientTopLeftToBottomRight,   
        GradientTopRightToBottomLeft,   
        GradientBottomLeftToTopRight,   
        GradientBottomRightToTopLeft,   
    };

    enum class Type : uint32_t
    {
        Standard,           
        Lightweight         
    };

    enum class Border : uint32_t
    {
        None,               
        Inset,              
        InsetBold,          
        Overlay,            
        OverlayBold         
    };


    enum class RenderingAlgorithm : uint32_t
    {
        ZBuffer,            

        HiddenLine,         

        FastHiddenLine,     

        Priority            
    };

private:
    Subwindow() {}
};
//End Subwindow

class HPS_API Style
{
public:

    enum class Type : uint32_t
    {
        Segment,        
        Named           
    };

    enum class AppendMode : uint32_t
    {
        None,       
        And,        
        Or          
    };

private:
    Style() {}
};


class HPS_API Shell
{
public:

    enum class Component : uint32_t
    {
        Faces,      
        Edges,      
        Vertices    
    };

    /* \enum ToleranceUnits
     * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
    enum class ToleranceUnits : uint32_t
    {
        ObjectSpace,            
        FeatureSizePercentage   
    };

    /* \enum HandednessOptimization
     * Enumerates the shell optimization options with regards to handedness. */
    enum class HandednessOptimization : uint32_t
    {
        None,                   
        Fix,                    
        Reverse                 
    };

    /* \enum RelationResults
     * Enumerates the results of a shell relation computation. */
    enum class Relation : uint32_t
    {
        On,                     
        Off,                    
        In,                     
        Out                     
    };

    /* \enum RelationTest
     * Enumerates the test options for a shell relation computation. */
    enum class RelationTest : uint32_t
    {
        Simple,                 
        Enclosure,              
        Distance                
    };

private:
    Shell() {}
};


class HPS_API Mesh
{
public:

    enum class Component : uint32_t
    {
        Faces,      
        Edges,      
        Vertices    
    };

private:
    Mesh() {}
};


class HPS_API InfiniteLine
{
public:

    enum class Type : uint32_t
    {
        Line,       
        Ray         
    };

private:
    InfiniteLine() {}
};


class HPS_API Trim
{
public:

    enum class Type : uint32_t
    {
        Line,           
        Curve           
    };

    enum class Operation : uint32_t
    {
        Keep,           
        Remove          
    };

private:
    Trim() {}
};


class HPS_API Spotlight
{
public:

    enum class OuterConeUnits : uint32_t
    {
        Degrees,
        FieldRadius
    };

    enum class InnerConeUnits : uint32_t
    {
        Degrees,
        FieldRadius,
        Percent
    };

private:
    Spotlight() {}
};


class HPS_API Cylinder
{
public:

    enum class Component : uint32_t
    {
        Faces,              
        Edges,              
    };

    enum class Capping : uint32_t
    {
        None,               
        First,              
        Last,               
        Both                
    };

    enum class Orientation : uint32_t
    {
        Default,            
        DefaultRadii,       
        InvertRadii,        
        InvertRadiiOnly,    
        DefaultColors,      
        InvertColors,       
        InvertColorsOnly,   
        InvertAll           
    };

private:
    Cylinder() {}
};


class HPS_API HighlightSearch
{
public:

    enum class Scope : uint32_t
    {
        AtOrAbovePath,  
        AtOrBelowPath,  
        ExactPath       
    };

private:
    HighlightSearch() {}
};

class HPS_API Search
{
public:

    enum class Space : uint32_t
    {
        SegmentOnly,                
        Subsegments,                
        SubsegmentsAndIncludes      
    };

    enum class Behavior : uint32_t
    {
        Exhaustive,                 
        FirstMatch                  
    };
    
    enum class Type : uint32_t
    {
        None                                        = 0x00000000,   
        Everything                                  = 0x00ffffff,   

        Include                                     = 0x00000042,   
        Segment                                     = 0x00000043,   

        Includer                                    = 0x00000100,   

        // Geometry
        Geometry                                    = 0x10000000,   

        CuttingSection                              = 0x10000026,   
        Shell                                       = 0x10000028,   
        Mesh                                        = 0x10000029,   
        Grid                                        = 0x1000002a,   
        NURBSSurface                                = 0x1000002b,   
        Cylinder                                    = 0x1000002d,   
        Sphere                                      = 0x1000002e,   
        Polygon                                     = 0x1000002f,   
        Circle                                      = 0x10000030,   
        //unused                                    = 0x10000031,
        CircularWedge                               = 0x10000032,   
        Ellipse                                     = 0x10000033,   
        Line                                        = 0x10000034,   
        NURBSCurve                                  = 0x10000037,   
        CircularArc                                 = 0x10000038,   
        EllipticalArc                               = 0x10000039,   
        InfiniteLine                                = 0x1000003a,   
        //unused                                    = 0x1000003b,
        Marker                                      = 0x1000003c,   
        Text                                        = 0x1000003e,   
        Reference                                   = 0x10000041,   

        DistantLight                                = 0x10000100,   
        Spotlight                                   = 0x10000101,   
        InfiniteRay                                 = 0x10000102,   

        // Attributes
        Attribute                                   = 0x20000000,   
        
        Priority                                    = 0x20000001,   

        // Simple Attributes
        Material                                    = 0x2000000b,   
        PBRMaterial                                 = 0x2000000c,   
        Camera                                      = 0x2000000f,   
        ModellingMatrix                             = 0x20000011,   
        UserData                                    = 0x20000022,   
        TextureMatrix                               = 0x20000024,   

        // Complex Attributes
        Culling                                     = 0x20001000,   
        CullingBackFace                             = 0x20001001,   
        CullingExtent                               = 0x20001002,   
        CullingVector                               = 0x20001003,   
        CullingVectorTolerance                      = 0x20001004,   
        CullingFrustum                              = 0x20001005,   
        CullingDeferralExtent                       = 0x20001006,   
        CullingVolume                               = 0x20001007,   
        CullingDistance                             = 0x20001008,   

        CurveAttribute                              = 0x20002000,   
        CurveAttributeBudget                        = 0x20002001,   
        CurveAttributeContinuedBudget               = 0x20002002,   
        CurveAttributeViewDependent                 = 0x20002003,   
        CurveAttributeMaximumDeviation              = 0x20002004,   
        CurveAttributeMaximumAngle                  = 0x20002005,   
        CurveAttributeMaximumLength                 = 0x20002006,   

        CylinderAttribute                           = 0x20003000,   
        CylinderAttributeTessellation               = 0x20003001,   
        CylinderAttributeOrientation                = 0x20003002,   

        EdgeAttribute                               = 0x20004000,   
        EdgeAttributePattern                        = 0x20004016,   
        EdgeAttributeWeight                         = 0x20004017,   
        EdgeAttributeHardAngle                      = 0x20004018,   

        LightingAttribute                           = 0x20005000,   
        LightingAttributeInterpolation              = 0x20005001,   

        LineAttribute                               = 0x20006000,   
        LineAttributePattern                        = 0x2000601a,   
        LineAttributeWeight                         = 0x2000601b,   

        MarkerAttribute                             = 0x20007000,   
        MarkerAttributeGlyphRotation                = 0x2000701a,   
        MarkerAttributeSize                         = 0x2000701c,   
        MarkerAttributeSymbol                       = 0x2000701d,   
        MarkerAttributePreference                   = 0x2000701e,   

        SurfaceAttribute                            = 0x20008000,   
        SurfaceAttributeBudget                      = 0x20008001,   
        SurfaceAttributeMaximumFacetDeviation       = 0x20008002,   
        SurfaceAttributeMaximumFacetAngle           = 0x20008003,   
        SurfaceAttributeMaximumFacetWidth           = 0x20008004,   
        SurfaceAttributeTrimCurveBudget             = 0x20008005,   
        SurfaceAttributeMaximumTrimCurveDeviation   = 0x20008006,   

        Selectability                               = 0x20009000,   
        SelectabilityWindows                        = 0x20009001,   
        SelectabilityEdges                          = 0x20009002,   
        SelectabilityFaces                          = 0x20009003,   
        SelectabilityLights                         = 0x20009004,   
        SelectabilityLines                          = 0x20009005,   
        SelectabilityMarkers                        = 0x20009006,   
        SelectabilityVertices                       = 0x20009007,   
        SelectabilityText                           = 0x20009008,   

        SphereAttribute                             = 0x2000a000,   
        SphereAttributeTessellation                 = 0x2000a001,   

        Subwindow                                   = 0x2000b000,   
        SubwindowEitherType                         = 0x2000b001,   
        SubwindowStandard                           = 0x2000b00e,   
        SubwindowLightweight                        = 0x2000b002,   
        SubwindowBackground                         = 0x2000b003,   
        SubwindowBorder                             = 0x2000b004,   
        SubwindowRenderingAlgorithm                 = 0x2000b005,   

        TextAttribute                               = 0x2000c000,   
        TextAttributeAlignment                      = 0x2000c01e,   
        TextAttributeBold                           = 0x2000c002,   
        TextAttributeItalic                         = 0x2000c003,   
        TextAttributeOverline                       = 0x2000c004,   
        TextAttributeStrikethrough                  = 0x2000c005,   
        TextAttributeUnderline                      = 0x2000c006,   
        TextAttributeSlant                          = 0x2000c007,   
        TextAttributeLineSpacing                    = 0x2000c008,   
        TextAttributeRotation                       = 0x2000c00a,   
        TextAttributeExtraSpace                     = 0x2000c00b,   
        TextAttributeGreeking                       = 0x2000c00c,   
        TextAttributeSizeTolerance                  = 0x2000c00d,   
        TextAttributeSize                           = 0x2000c00e,   
        TextAttributeFont                           = 0x2000c00f,   
        TextAttributeTransform                      = 0x2000c010,   
        TextAttributeRenderer                       = 0x2000c011,   
        TextAttributePreference                     = 0x2000c012,   
        TextAttributePath                           = 0x2000c020,   
        TextAttributeSpacing                        = 0x2000c021,   
        TextAttributeBackground                     = 0x2000c022,   
        TextAttributeBackgroundMargins              = 0x2000c023,   
        TextAttributeBackgroundStyle                = 0x2000c024,   
        TextAttributeLeaderLine                     = 0x2000c025,   

        Transparency                                = 0x2000d000,   
        TransparencyMethod                          = 0x2000d001,   
        TransparencyAlgorithm                       = 0x2000d002,   
        TransparencyDepthPeelingLayers              = 0x2000d004,   
        TransparencyDepthPeelingMinimumArea         = 0x2000d005,   
        TransparencyDepthWriting                    = 0x2000d006,   

        Visibility                                  = 0x2000e000,   
        VisibilityCuttingSections                   = 0x2000e001,   
        VisibilityCutEdges                          = 0x2000e002,   
        VisibilityCutFaces                          = 0x2000e003,   
        VisibilityWindows                           = 0x2000e004,   
        VisibilityText                              = 0x2000e005,   
        VisibilityLines                             = 0x2000e006,   
        VisibilityEdgeLights                        = 0x2000e007,   
        VisibilityMarkerLights                      = 0x2000e008,   
        VisibilityFaceLights                        = 0x2000e009,   
        VisibilityGenericEdges                      = 0x2000e00a,   
        VisibilityHardEdges                         = 0x2000e00b,   
        VisibilityAdjacentEdges                     = 0x2000e00c,   
        VisibilityInteriorSilhouetteEdges           = 0x2000e00d,   
        VisibilityShadowEmitting                    = 0x2000e00e,   
        VisibilityShadowReceiving                   = 0x2000e00f,   
        VisibilityShadowCasting                     = 0x2000e010,   
        VisibilityMarkers                           = 0x2000e011,   
        VisibilityVertices                          = 0x2000e012,   
        VisibilityFaces                             = 0x2000e013,   
        VisibilityPerimeterEdges                    = 0x2000e014,   
        VisibilityNonCulledEdges                    = 0x2000e015,   
        VisibilityMeshQuadEdges                     = 0x2000e016,   
        VisibilityEdges                             = 0x2000e017,   
        VisibilityLeaderLines                       = 0x2000e018,   

        VisualEffects                               = 0x2000f000,   
        VisualEffectsPostProcessEffectsEnabled      = 0x2000f001,   
        VisualEffectsAntiAliasing                   = 0x2000f002,   
        VisualEffectsShadowMaps                     = 0x2000f003,   
        VisualEffectsSimpleShadow                   = 0x2000f004,   
        VisualEffectsSimpleShadowPlane              = 0x2000f005,   
        VisualEffectsSimpleShadowLightDirection     = 0x2000f006,   
        VisualEffectsSimpleShadowColor              = 0x2000f007,   
        VisualEffectsSimpleReflection               = 0x2000f008,   
        VisualEffectsSimpleReflectionPlane          = 0x2000f009,   
        VisualEffectsSimpleReflectionVisibility     = 0x2000f00a,   
        VisualEffectsEyeDomeLightingBackColor       = 0x2000f00b,   

        Performance                                 = 0x20010000,   
        PerformanceDisplayLists                     = 0x20010001,   
        PerformanceStaticModel                      = 0x20010002,   
        StaticModelSegment                          = 0x40000043,   

        DrawingAttribute                            = 0x20011000,   
        DrawingAttributePolygonHandedness           = 0x20011001,   
        DrawingAttributeDepthRange                  = 0x20011002,   
        DrawingAttributeFaceDisplacement            = 0x20011003,   
        DrawingAttributeGeneralDisplacement         = 0x20011004,   
        DrawingAttributeVertexDisplacement          = 0x20011005,   
        DrawingAttributeOverlay                     = 0x20011006,   
        DrawingAttributeDeferral                    = 0x20011007,   
        DrawingAttributeVertexDecimation            = 0x20011008,   
        DrawingAttributeVertexRandomization         = 0x20011009,   
        DrawingAttributeOverrideInternalColor       = 0x2001100a,   
        DrawingAttributeClipRegion                  = 0x20011013,   
        DrawingAttributeWorldHandedness             = 0x20011019,   

        
        HiddenLineAttribute                         = 0x20012000,   
        HiddenLineAttributeAlgorithm                = 0x20012001,   
        HiddenLineAttributeColor                    = 0x20012002,   
        HiddenLineAttributeDimFactor                = 0x20012003,   
        HiddenLineAttributeFaceDisplacement         = 0x20012004,   
        HiddenLineAttributeLinePattern              = 0x20012005,   
        HiddenLineAttributeLineSort                 = 0x20012006,   
        HiddenLineAttributeRenderFaces              = 0x20012007,   
        HiddenLineAttributeRenderText               = 0x20012008,   
        HiddenLineAttributeSilhouetteCleanup        = 0x20012009,   
        HiddenLineAttributeTransparencyCutoff       = 0x2001200a,   
        HiddenLineAttributeVisibility               = 0x2001200b,   
        HiddenLineAttributeWeight                   = 0x2001200c,   
        

        SegmentStyle                                = 0x20013001,   
        NamedStyle                                  = 0x20013002,   
        MaterialPalette                             = 0x20013003,   
        Portfolio                                   = 0x20013004,   

        ContourLine                                 = 0x20014000,   
        ContourLineVisibility                       = 0x20014001,   
        ContourLinePosition                         = 0x20014002,   
        ContourLineColor                            = 0x20014003,   
        ContourLinePattern                          = 0x20014004,   
        ContourLineWeight                           = 0x20014005,   
        ContourLineLighting                         = 0x20014006,   

        Condition                                   = 0x20015000,   

        Bounding                                    = 0x20016000,   
        BoundingVolume                              = 0x20016001,   
        BoundingExclusion                           = 0x20016002,   
        
        AttributeLock                               = 0x20017000,   
        AttributeLockSetting                        = 0x20017001,   
        AttributeLockSubsegmentOverride             = 0x20017002,   

        TransformMask                               = 0x20018000,   
        TransformMaskCamera                         = 0x20018001,   
        TransformMaskCameraTranslation              = 0x20018002,   
        TransformMaskCameraScale                    = 0x20018003,   
        TransformMaskCameraOffset                   = 0x20018004,   
        TransformMaskCameraRotation                 = 0x20018005,   
        TransformMaskCameraPerspectiveScale         = 0x20018006,   
        TransformMaskCameraProjection               = 0x20018007,   
        TransformMaskModellingMatrix                = 0x20018008,   
        TransformMaskModellingMatrixTranslation     = 0x20018009,   
        TransformMaskModellingMatrixScale           = 0x20018010,   
        TransformMaskModellingMatrixOffset          = 0x20018011,   
        TransformMaskModellingMatrixRotation        = 0x20018012,   

        ColorInterpolation                          = 0x20019000,   
        ColorInterpolationFaceColor                 = 0x20019001,   
        ColorInterpolationEdgeColor                 = 0x20019002,   
        ColorInterpolationMarkerColor               = 0x20019003,   
        ColorInterpolationFaceIndex                 = 0x20019004,   
        ColorInterpolationEdgeIndex                 = 0x20019005,   
        ColorInterpolationMarkerIndex               = 0x20019006,   

        CuttingSectionAttribute                     = 0x2001a000,   
        CuttingSectionAttributeCuttingLevel         = 0x2001a001,   
        CuttingSectionAttributeCappingLevel         = 0x2001a002,   
        CuttingSectionAttributeMaterialPreference   = 0x2001a003,   
        CuttingSectionAttributeEdgeWeight           = 0x2001a004,   
        CuttingSectionAttributeTolerance            = 0x2001a005,   
        CuttingSectionAttributeCappingUsage         = 0x2001a006,   

    };

private:
    Search() {}
};


class HPS_API Material
{
public:

    enum class Type : uint32_t
    {
        None                    =  0,       
        FullMaterial,                       
        RGBColor,                           
        RGBAColor,                          
        MaterialIndex,                      
        TextureName,                        
        ModulatedTexture,                   
        CubeMapName,                        
        ModulatedCubeMap,                   
        GlossValue,                         
        DiffuseChannelAlpha                 
    };

    enum class Channel : uint32_t
    {
        DiffuseColor = 1,       
        DiffuseTexture = 2,     
        Specular = 3,           
        Emission = 4,           
        Transmission = 5,       
        Mirror = 6,             
        Bump = 7,               
        EnvironmentTexture = 8, 
        EnvironmentCubeMap = 9, 
        Gloss = 10,             
        Alpha = 11              
    };

    class HPS_API Color 
    {
    public: 

        enum class Channel : uint32_t 
        {
            DiffuseColor = 1,               
            Specular = 3,                   
            Emission = 4,                   
            Mirror   = 6                    
        };

    private:
        Color() {}
    };
    
    class HPS_API Texture 
    {
    public:

        enum class Channel : uint32_t 
        {
            DiffuseTexture = 2,         
            Specular = 3,               
            Emission = 4,               
            Transmission = 5,           
            Mirror = 6,                 
            Bump = 7,                   
            EnvironmentTexture = 8,     
            EnvironmentCubeMap = 9      
        };

        enum class Parameterization : uint32_t 
        {
            Cylinder,

            PhysicalReflection,
            
            Object,
            
            NaturalUV,
            
            ReflectionVector,
            
            SurfaceNormal,
            
            Sphere,
            
            UV,
            
            World
        };

        enum class Tiling : uint32_t 
        {
            Clamp,
            
            Repeat,
            
            Reflect,
            
            Trim
        };

        enum class Interpolation : uint32_t 
        {
            None,

            Bilinear
        };

        enum class Decimation : uint32_t 
        {
            None,
            
            Anisotropic,
            
            Mipmap
        };

        enum class ChannelMapping : uint32_t 
        {
            Red,        
            Green,      
            Blue,       
            Alpha,      
            Zero,       
            One,        
            Luminance   
        };

    private:    
        Texture() {}
    };

private:
    Material() {}
};


class HPS_API PostProcessEffects
{
public:

    class HPS_API AmbientOcclusion
    {
    public:

        enum class Quality : uint32_t
        {
            Fastest,            
            Nicest              
        };

    private:
        AmbientOcclusion() {}
    };

    class HPS_API Bloom
    {
    public:
        enum class Shape : uint32_t
        {
            Star,           
            Radial          
        };

    private:
        Bloom() {}
    };

private:
    PostProcessEffects() {}
};

class HPS_API Performance
{
public:

    enum class DisplayLists : uint32_t
    {
        None,

        Geometry,

        Segment
    };

    enum class StaticModel : uint32_t
    {
        None,               
        Attribute,          
        AttributeSpatial    
    };

    enum class StaticConditions : uint32_t
    {
        Independent,

        Single

        /* placeholder.  Option would generate different optimized trees at the cost of memory. */
        //Multiple      //!< An optimized segment tree will be used for rendering.   The tree will be sorted based on both attributes and spatial locations of objects.  This is particularly useful for very large, spatially dispersed models.
    };

    
private:
    Performance() {}
};


class HPS_API AttributeLock
{
public:

    enum class Type : uint32_t
    {
        Everything                          = 0x01000000,

        Visibility                          = 0x02000000,

        VisibilityCuttingSections,
        VisibilityCutEdges,
        VisibilityCutFaces,
        VisibilityWindows,
        VisibilityText,
        VisibilityLines,
        VisibilityEdgeLights,
        VisibilityMarkerLights,
        VisibilityFaceLights,
        VisibilityGenericEdges,
        VisibilityHardEdges,
        VisibilityAdjacentEdges,
        VisibilityInteriorSilhouetteEdges,
        VisibilityShadowEmitting,
        VisibilityShadowReceiving,
        VisibilityShadowCasting,
        VisibilityMarkers,
        VisibilityVertices,
        VisibilityFaces,
        VisibilityPerimeterEdges,
        VisibilityNonCulledEdges,
        VisibilityMeshQuadEdges,
        VisibilityCutGeometry,
        VisibilityEdges,
        VisibilityGeometry,
        VisibilityLights,
        VisibilityShadows,

        Material                            = 0x03000000,

        MaterialGeometry,
        MaterialCutGeometry,

        MaterialAmbientLightUpColor,
        MaterialAmbientLightDownColor,
        MaterialAmbientLightColor,

        MaterialWindowColor,
        MaterialWindowContrastColor,

        MaterialLightColor,
        MaterialLineColor,
        MaterialMarkerColor,
        MaterialTextColor,
        MaterialCutEdgeColor,

        MaterialVertex,
        MaterialVertexDiffuse,
        MaterialVertexDiffuseColor,
        MaterialVertexDiffuseAlpha,
        MaterialVertexDiffuseTexture,
        MaterialVertexSpecular,
        MaterialVertexMirror,
        MaterialVertexTransmission,
        MaterialVertexEmission,
        MaterialVertexEnvironment,
        MaterialVertexBump,
        MaterialVertexGloss,

        MaterialEdge,
        MaterialEdgeDiffuse,
        MaterialEdgeDiffuseColor,
        MaterialEdgeDiffuseAlpha,
        MaterialEdgeDiffuseTexture,
        MaterialEdgeSpecular,
        MaterialEdgeMirror,
        MaterialEdgeTransmission,
        MaterialEdgeEmission,
        MaterialEdgeEnvironment,
        MaterialEdgeBump,
        MaterialEdgeGloss,

        MaterialFace,
        MaterialFaceDiffuse,
        MaterialFaceDiffuseColor,
        MaterialFaceDiffuseAlpha,
        MaterialFaceDiffuseTexture,
        MaterialFaceSpecular,
        MaterialFaceMirror,
        MaterialFaceTransmission,
        MaterialFaceEmission,
        MaterialFaceEnvironment,
        MaterialFaceBump,
        MaterialFaceGloss,

        MaterialBackFace,
        MaterialBackFaceDiffuse,
        MaterialBackFaceDiffuseColor,
        MaterialBackFaceDiffuseAlpha,
        MaterialBackFaceDiffuseTexture,
        MaterialBackFaceSpecular,
        MaterialBackFaceMirror,
        MaterialBackFaceTransmission,
        MaterialBackFaceEmission,
        MaterialBackFaceEnvironment,
        MaterialBackFaceBump,
        MaterialBackFaceGloss,

        MaterialFrontFace,
        MaterialFrontFaceDiffuse,
        MaterialFrontFaceDiffuseColor,
        MaterialFrontFaceDiffuseAlpha,
        MaterialFrontFaceDiffuseTexture,
        MaterialFrontFaceSpecular,
        MaterialFrontFaceMirror,
        MaterialFrontFaceTransmission,
        MaterialFrontFaceEmission,
        MaterialFrontFaceEnvironment,
        MaterialFrontFaceBump,
        MaterialFrontFaceGloss,

        MaterialCutFace,
        MaterialCutFaceDiffuse,
        MaterialCutFaceDiffuseColor,
        MaterialCutFaceDiffuseAlpha,
        MaterialCutFaceDiffuseTexture,
        MaterialCutFaceSpecular,
        MaterialCutFaceMirror,
        MaterialCutFaceTransmission,
        MaterialCutFaceEmission,
        MaterialCutFaceEnvironment,
        MaterialCutFaceBump,
        MaterialCutFaceGloss,

        Camera                          = 0x04000000,
    };

private:
    AttributeLock() {}
};

class HPS_API Drawing
{
public:

    enum class Handedness : uint32_t
    {
        None,                   
        Left,                   
        Right                   
    };

    enum class Overlay : uint32_t
    {
        None,
        
        Default,
        
        WithZValues,

        InPlace,
    };

    enum class ClipOperation : uint32_t
    {
        Keep,       
        Remove,     
    };

    enum class ClipSpace : uint32_t
    {
        Window,     
        World,      
        Object,     
    };

private:
    Drawing() {}
};


class HPS_API HiddenLine
{
public:

    enum class Algorithm : uint32_t
    {
        None,   
        ZBuffer,
        ZSort,  
    };

private:
    HiddenLine() {}
};


class HPS_API Selection
{
public:

    enum class Level : uint32_t
    {
        Segment,            
        Entity,             
        Subentity,          
    };

    enum class Sorting: uint32_t
    {
        Off,        

        Proximity,

        ZSorting,   

        Default     
    };

    enum class Algorithm : uint32_t
    {
        Visual,

        Analytic
    };

    enum class Granularity : uint32_t
    {
        General,            
        Detailed            
    };

private:
    Selection() {}
};



class HPS_API Camera
{
public:

    enum class Projection : uint32_t
    {
        Default     = 1 ,       
        Perspective,            
        Orthographic,           
        Stretched,              
    };

private:
    Camera() {}
};


class HPS_API Selectability
{
public:
    enum class Value : uint32_t
    {
        Off = 0,    
        On,         
        ForcedOn    
    };

private:
    Selectability() {}
};


class HPS_API Transparency
{
public:

    enum class Method : uint32_t
    {
        None,           
        Blended,        
        ScreenDoor      
    };

    enum class Algorithm : uint32_t
    {
        None,           
        Painters,       
        ZSortNicest,    
        ZSortFastest,   
        DepthPeeling,   
        WeightedBlended 
    };

    enum class AreaUnits : uint32_t
    {
        Percent,    
        Pixels      
    };

    enum class Preference
    {
        Nicest, 
        Fastest, 
    };

private:
    Transparency() {}
};


class HPS_API Marker
{
public:
    enum class DrawingPreference : uint32_t
    {
        Nicest, // !< Markers should always be drawn at the requested size at the possible cost of performance.
        Fastest, 
    };

    enum class SizeUnits : uint32_t
    {
        ScaleFactor,            
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels                  
    };

private:
    Marker() {}
};


class HPS_API Lighting 
{
public:

    enum class InterpolationAlgorithm : uint32_t 
    {
        Phong,      
        Gouraud,    
        Flat        
    };

private:
    Lighting() {}
};

class HPS_API Text
{
public:

    enum class Alignment : uint32_t
    {
        TopLeft,                    
        CenterLeft,                 
        BottomLeft,                 
        TopCenter,                  
        Center,                     
        BottomCenter,               
        TopRight,                   
        CenterRight,                
        BottomRight                 
    };

    enum class ReferenceFrame : uint32_t
    {
        WorldAligned,               
        PathAligned                 
    };
    
    enum class Justification : uint32_t
    {
        Left,                       
        Right,                      
        Center                      
    };
    
    enum class Transform : uint32_t
    {
        Transformable,
        NonTransformable,
        CharacterPositionOnly,
        CharacterPositionAdjusted,
        NonScalingTransformable
    };

    enum class Renderer : uint32_t
    {
        Default,                    
        Driver,                     
        Truetype,                   
    };

    enum class Preference : uint32_t
    {
        Default,                    
        Vector,                     
        Raster,                     
        Exterior                    
    };

    enum class Rotation : uint32_t
    {
        None,                       
        Rotate,                     
        FollowPath                  
    };


    enum class SizeUnits : uint32_t
    {
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels                  
    };

    enum class SizeToleranceUnits : uint32_t
    {
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels,                 
        Percent                 
    };

    enum class MarginUnits : uint32_t
    {
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels,                 
        Percent                 
    };

    enum class GreekingUnits : uint32_t
    {
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels                  
    };

    enum class GreekingMode : uint32_t
    {
        Nothing,                
        Lines,                  
        Box                     
    };

    enum class RegionAlignment : uint32_t
    {
        Top,                    
        Center,                 
        Bottom                  
    };

    enum class LeaderLineSpace : uint32_t
    {
        Object,                 
        World,                  
    };

    enum class RegionFitting : uint32_t
    {
        Left,                   
        Center,                 
        Right,                  
        Spacing,                
        Width,                  
        Auto,                   
    };
private:
    Text() {}
};


class HPS_API Line
{
public:

    enum class CoordinateSpace : uint32_t
    {
        Object, 
        World, 
        NormalizedInnerWindow, 
        NormalizedInnerPixel 
    };

    enum class SizeUnits : uint32_t
    {
        ScaleFactor,            
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels                  
    };

private:
    Line() {}
};


class HPS_API Edge
{
public:

    enum class SizeUnits : uint32_t
    {
        ScaleFactor,            
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels                  
    };

private:
    Edge() {}
};


class HPS_API CuttingSection
{
public:

    enum class Mode : uint32_t
    {
        None,       
        Round,      
        Square,     
        Plane 
    };

    enum class CappingLevel : uint32_t
    {
        Entity,             
        Segment,            
        SegmentTree         
    };

    enum class CappingUsage : uint32_t
    {
        Off,                
        On,                 
        Visibility          
    };

    enum class ToleranceUnits : uint32_t
    {
        Percent,                
        WorldSpace,             
    };

    enum class CuttingLevel : uint32_t
    {
        Global,             
        Local,              
    };

    enum class MaterialPreference : uint32_t
    {
        Explicit,           
        Implicit,           
    };

    enum class GatheringLevel : uint32_t
    {
        Segment,                
        SegmentTree             
    };

private:
    CuttingSection() {}
};

class HPS_API ContourLine
{
public:

    enum class Mode : uint32_t
    {
        Repeating,  
        Explicit,   
    };

private:
    ContourLine() {}
};

enum class IOResult : uint32_t
{
    Success,                        
    Failure,                        
    FileNotFound,                   
    UnableToOpenFile,               
    InvalidOptions,                 
    InvalidSegment,                 
    InProgress,                     
    Canceled,                       
    UnableToLoadLibraries,          
    VersionIncompatibility,         
    InitializationFailed,           
    UnsupportedFormat,              
    InvalidFile,                    
};

class HPS_API LinePattern
{
public:

    enum class SizeUnits : uint32_t
    {
        ObjectSpace,            
        SubscreenRelative,      
        WindowRelative,         
        WorldSpace,             
        Points,                 
        Pixels,                 
        ScaleFactor             
    };

    enum class InsetBehavior : uint32_t
    {
        Overlap,                
        Trim,                   
        Inline                  
    };

    enum class Join : uint32_t
    {
        Mitre,              
        Round,              
        Bevel               
    };

    enum class Cap : uint32_t
    {
        Butt,
        Square,
        Round,
        Mitre
    };

    enum class Justification : uint32_t
    {
        Center,
        Stretch
    };

    enum class Modifier : uint32_t
    {
        GlyphName,              
        Enumerated              
    };


    enum class Default : uint32_t
    {
        Solid,                  
        DashDot,                
        Dashed,                 
        Dotted,                 
        Dash2Dot,               
        Dash3Dot,               
        LongDash,               
        LongDashShortDash,      
        LongDash2ShortDash,     
        FineDot,                
    };

private:
    LinePattern() {}
};


class HPS_API Shape
{
public:
    enum class Default : uint32_t
    {
        Rectangle,          
        RoundedRectangle,   
        Oval,               
        Ellipse,            
    };

private:
    Shape() {}
};


//Begin Glyphs
class HPS_API Glyph
{
public:

    enum class Fill : uint32_t
    {
        None,                   
        Continuous,             
        New,                    
        NewLoop                 
    };

    enum class ColorSource : uint32_t
    {
        Default,                    
        Explicit,               
        Indexed                 
    };

    enum class Default : uint32_t
    {
        Circle,                 
        CircleWithDot,          
        CircleWithPlus,         
        CircleWithTimes,        
        CircleWithCircle,       
        SolidCircle,            
        Dot,                    
        Plus,                   
        Times,                  
        Splat,                  
        Box,                    
        BoxWithDot,             
        BoxWithTimes,           
        SolidBox,               
        Diamond,                
        DiamondWithDot,         
        DiamondWithPlus,        
        SolidDiamond,           
        TriangleUp,             
        TriangleUpWithDot,      
        SolidTriangleUp,        
        TriangleDown,           
        TriangleDownWithDot,    
        SolidTriangleDown,      
        TriangleRight,          
        TriangleRightWithDot,   
        SolidTriangleRight,     
        TriangleLeft,           
        TriangleLeftWithDot,    
        SolidTriangleLeft,      
        TriangleUpV,            
        SolidTriangleUpV,       
        TriangleDownV,          
        SolidTriangleDownV,     
        TriangleRightV,         
        SolidTriangleRightV,    
        TriangleLeftV,          
        SolidTriangleLeftV,     
        LetterY,                
        LetterZ,                
        CircleLetterY,          
        CircleLetterZ,          
        VerticalBar,            
        HorizontalBar,          
        SlantLeft,              
        SlantRight,             
        WidePlus,               
        SolidWidePlus,          
        WideTimes,              
        SolidWideTimes,         
        Pound,                  
        Sphere,                 
    };
    
private:
    Glyph() {}
};


class HPS_API Bounding
{
public:

    enum class Type : uint32_t
    {
        None,
        Sphere,     
        Cuboid      
    };
    
private:
    Bounding() {}
};


class HPS_API Condition
{
public:

    enum class Intrinsic : uint32_t
    {
        Extent,
        DrawPass,
        InnerPixelWidth,
        InnerPixelHeight,
        Selection,
        QuickMovesProbe,
    };

private:
    Condition() {}
};


class HPS_API Grid
{
public:

    enum class Type : uint32_t
    {
        Quadrilateral,  
        Radial          
    };

private:
    Grid() {}
};


class HPS_API SegmentOptimizationOptions
{
public:

    enum class UserData : uint32_t
    {
        None,
        Discard,
        Preserve,
        Merge,
        Localize,
    };

    enum class Scope : uint32_t
    {
        SubSegments,
        SubsegmentsAndIncludes,
        SegmentOnly,
    };

    enum class Expansion : uint32_t
    {
        None,
        Includes,
        References,
        IncludesAndReferences,
    };

    enum class Matrix : uint32_t
    {
        None,
        Localize,
        Collapse,
    };

    enum class Reorganization : uint32_t
    {
        None,
        Attribute,
        Spatial,
        AttributeSpatial,
    };

private:
    SegmentOptimizationOptions() {}
};


class HPS_API Coordinate
{
public:

    enum class Space : uint32_t
    {
        Object,                 
        World,                  
        Camera,                 
        Window,                 
        Pixel,                  
        InnerWindow,            
        InnerPixel,             
        NormalizedInnerWindow,  
        NormalizedInnerPixel,   
        NormalizedWindow,       
        NormalizedPixel,        
    };

private:
    Coordinate() {}
};

class HPS_API Extent
{
public:

    enum class ClipRegion : uint32_t
    {
        Include,
        Ignore
    };

private:
    Extent() {}
};

class HPS_API GPU
{
public:

    enum class Preference
    {
        HighPerformance,    
        Integrated,         
        Specific,           
        Default,            
    };

private:
    GPU() {}
};

    typedef double          Time;

#ifdef _MSC_VER
#   ifndef HPS_INLINE
#       define  HPS_INLINE      __forceinline
#   endif
#else
#   define HPS_INLINE inline
#endif

#ifndef HPS_UNREFERENCED
#define HPS_UNREFERENCED(param) ((void)(param))
#endif


const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;

template<typename T>
HPS_INLINE T Degrees_To_Radians(T const & degrees)
{
    return degrees * (T)(PI / 180.0);
}

template<typename T>
HPS_INLINE T Radians_To_Degrees(T const & radians)
{
    return radians * (T)(180.0 / PI);
}

template<typename T>
HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
    T a = Degrees_To_Radians(angle);
    cosine = cos(a);
    sine = sin(a);
}

template<typename T>
HPS_INLINE T Cos(T const & angle) {
    return cos (Degrees_To_Radians(angle));
}

template<typename T>
HPS_INLINE T Sin(T const & angle) {
    return sin (Degrees_To_Radians(angle));
}

template<typename T>
HPS_INLINE T ACos(T const & x) {
    if (x > 1)
        return 0;
    if (x < -1)
        return 180;
    return Radians_To_Degrees(acos(x));
}

template<typename T>
HPS_INLINE T ATan2(T const & y, T const & x) {
    if (x == 0 && y == 0)
        return 0;
    return Radians_To_Degrees(atan2(y, x));
}


template <typename F>   struct Float_Traits {};
template <> struct Float_Traits<float>  {
    typedef double  Alternative;
    static const int Type = 1;
    static float Epsilon () { return 1.0e-30f; }
};
template <> struct Float_Traits<double> {
    typedef float   Alternative;
    static const int Type = 2;
    static double Epsilon () { return 1.0e-300; }
};



class HPS_API Float {
private:
    enum Parts {
#       if HOOPS_BIGENDIAN
            High, Low
#       else
            Low, High
#       endif
    };

    // & functions for a float represented in an int, * version for a double in an array of 2 ints
    static HPS_INLINE bool is_infinite(int32_t const & v)   { return (v & 0x7FFFFFFF) == 0x7F800000; }
    static HPS_INLINE bool is_infinite(uint32_t const & v)  { return (v & 0x7FFFFFFF) == 0x7F800000; }
    static HPS_INLINE bool is_infinite(int32_t const * v)   { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
    static HPS_INLINE bool is_infinite(uint32_t const * v)  { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }

    static HPS_INLINE bool is_nan(int32_t const & v) {
        uint32_t    exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
        return exp == 0x7F800000 && mantissa != 0;
    }
    static HPS_INLINE bool is_nan(uint32_t const & v) {
        uint32_t    exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
        return exp == 0x7F800000 && mantissa != 0;
    }
    static HPS_INLINE bool is_nan(int32_t const * v) {
        uint32_t    exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
        return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
    }
    static HPS_INLINE bool is_nan(uint32_t const * v) {
        uint32_t    exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
        return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
    }

    static HPS_INLINE bool is_special(int32_t const & v)    { return (v & 0x7F800000) == 0x7F800000; }
    static HPS_INLINE bool is_special(uint32_t const & v)   { return (v & 0x7F800000) == 0x7F800000; }
    static HPS_INLINE bool is_special(int32_t const * v)    { return (v[High] & 0x7FF00000) == 0x7FF00000; }
    static HPS_INLINE bool is_special(uint32_t const * v)   { return (v[High] & 0x7FF00000) == 0x7FF00000; }
public:

    static const float Infinity;
    static const float NegativeInfinity;

    static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
    static HPS_INLINE bool IsInfinite(double const & a) {
        uint32_t    v[2];
        memcpy (v, &a, sizeof(double));
        return is_infinite (v);
    }

    static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
    static HPS_INLINE bool IsNAN(double const & a) {
        uint32_t    v[2];
        memcpy (v, &a, sizeof(double));
        return is_nan (v);
    }

    static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
    static HPS_INLINE bool IsAbnormal(double const & a) {
        uint32_t    v[2];
        memcpy (v, &a, sizeof(double));
        return is_special (v);
    }

    static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
    static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);

#ifndef HOOPS_DEFINED
    template <typename Alloc>
    static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
    {
        if (a.size() != b.size())
            return false; 

        auto it1 = a.begin(); 
        auto it2 = b.begin();
        auto const end = a.end(); 
        for ( ; it1 != end; ++it1, ++it2)
        {
            if (!Equals(*it1, *it2, tolerance))
                return false; 
        }
        return true; 
    }
#endif

    static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
        return extract_uint32_t(a) & 0x80000000;
    }
    static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
        uint32_t    v[2];
        memcpy (v, &a, sizeof(double));
        return v[High] & 0x80000000;
    }

    static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
        uint32_t    v = extract_uint32_t(a);
        v &= 0x7FFFFFFF;
        v |= sign_bit;
        inject_uint32_t(a, v);
    }
    static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
        uint32_t    v[2];
        memcpy (v, &a, sizeof(double));
        v[High] &= 0x7FFFFFFF;
        v[High] |= sign_bit;
        memcpy (&a, v, sizeof(double));
    }


    static HPS_INLINE unsigned char unit_to_byte(float const & a) {
        uint32_t    v = extract_uint32_t(a);

        v &= 0x7FFFFFFF;
        if (v < 0x3B800000)
            return 0;

        v--;

        uint32_t    exp = v >> 23;
        uint32_t    man = (v & 0x007FFFFF) | 0x00800000;

        return (unsigned char) (man >> (16 + 126 - exp));
    }

    static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
        uint32_t    v = extract_uint32_t(a);

        v &= 0x7FFFFFFF;
        if (v < 0x3B800000)
            return 0;

        v--;

        uint32_t    exp = v >> 23;
        uint32_t    man = (v & 0x007FFFFF) | 0x00800000;

        uint32_t    x = (man >> (16 + 126 - exp));

        return (unsigned char) ((x * (mix+1)) >> 8);
    }


    static HPS_INLINE bool match(float const & a, float const & b) {
        uint32_t va = extract_uint32_t(a);
        uint32_t vb = extract_uint32_t(b);

        if (((va | vb) & 0x7FFFFFFF) == 0)
            return true;

        return va == vb;
    }
    static HPS_INLINE bool match(double const & a, double const & b) {
        return a == b;
    }


    static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
        if (b < a)
            a = b;
    }
    static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
        if (b < a)
            a = b;
    }

    static HPS_INLINE void replace_if_larger(float & a, float const & b) {
        if (b > a)
            a = b;
    }
    static HPS_INLINE void replace_if_larger(double & a, double const & b) {
        if (b > a)
            a = b;
    }


    static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
        uint32_t i;
        memcpy(&i, &a, sizeof(float));
        return i;
    }

    static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
        memcpy(&a, &i, sizeof(float));
    }

    static HPS_INLINE float C2F(unsigned char x) {
        //return (float)x * (1.0f/255.0f);
        return char_to_float[x];
    }


    // SSE convenience functions
    static HPS_INLINE void pack_4(float const & f, float * m) {
        memcpy(&m[0], &f, sizeof(float));
        memcpy(&m[1], &f, sizeof(float));
        memcpy(&m[2], &f, sizeof(float));
        memcpy(&m[3], &f, sizeof(float));
    }

    static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
        memcpy(&m[0], &f0, sizeof(float));
        memcpy(&m[1], &f1, sizeof(float));
        memcpy(&m[2], &f2, sizeof(float));
        memcpy(&m[3], &f3, sizeof(float));
    }

    static HPS_INLINE void unpack_4(float * f0, float const * const m) {
        memcpy(f0, m, sizeof(float)*4);
    }

    static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
        memcpy(&f0, &m[0], sizeof(float));
        memcpy(&f1, &m[1], sizeof(float));
        memcpy(&f2, &m[2], sizeof(float));
        memcpy(&f3, &m[3], sizeof(float));
    }

private:
    static const float char_to_float[256];

    Float();
};




template <typename T>   HPS_INLINE  T * Alter (T const * a) { return const_cast<T *>(a); }
template <typename T>   HPS_INLINE  T & Alter (T const & a) { return const_cast<T &>(a); }

template <typename T>   HPS_INLINE  T       Abs (T const & a)                   { return  a < 0 ? -a : a; }
template <typename T>   HPS_INLINE  int     Compare (T const & a, T const & b)  { return a == b ? 0 : a < b ? -1 : 1;  }
template <typename T>   HPS_INLINE  int     Sign (T const & a)                  { return Compare(a,(T)0); }
template <typename T>   HPS_INLINE  void    Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
template <typename T>   HPS_INLINE  int     Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
template <typename T>   HPS_INLINE  int     Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }

template <typename T>   HPS_INLINE  T const &   Min (T const & a, T const & b)  { return  a < b ? a : b; }
template <typename T>   HPS_INLINE  T const &   Min (T const & a, T const & b, T const & c) { return  Min(Min(a,b),c); }
template <typename T>   HPS_INLINE  T const &   Min (T const & a, T const & b, T const & c, T const & d) { return Min(Min(a, b, c),d); }
template <typename T>   HPS_INLINE  T const &   Min (T const & a, T const & b, T const & c, T const & d, T const & e) { return Min(Min(a,b,c,d),e); }
template <typename T>   HPS_INLINE  T const &   Min (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Min(Min(a,b,c,d,e),f); }

template <typename T>   HPS_INLINE  T const &   Max (T const & a, T const & b)  { return  a > b ? a : b; }
template <typename T>   HPS_INLINE  T const &   Max (T const & a, T const & b, T const & c) { return  Max(Max(a,b),c); }
template <typename T>   HPS_INLINE  T const &   Max (T const & a, T const & b, T const & c, T const & d) { return Max(Max(a, b, c),d); }
template <typename T>   HPS_INLINE  T const &   Max (T const & a, T const & b, T const & c, T const & d, T const & e) { return Max(Max(a,b,c,d),e); }
template <typename T>   HPS_INLINE  T const &   Max (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Max(Max(a,b,c,d,e),f); }

template <typename T>   HPS_INLINE  T const &   Clamp(T const & x, T const & min, T const & max) { return x < min ? min : x > max ? max : x; }


template <> HPS_INLINE float    Abs<float> (float const & a) {
    uint32_t    v = Float::extract_uint32_t(a);
    v &= 0x7FFFFFFF;
    float f;
    Float::inject_uint32_t(f,v);
    return f;
}

template <> HPS_INLINE int  Sign<float> (float const & a) {
    uint32_t    v = Float::extract_uint32_t(a);

    if ((v & 0x7FFFFFFF) == 0)
        return 0;

    return ((int32_t)(v & 0x80000000)>>31) | 0x01;
}



HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
    int32_t     va = Float::extract_uint32_t(a);
    int32_t     vb = Float::extract_uint32_t(b);

    if (is_special(va) || is_special(vb)) {
        if (is_infinite(va) || is_infinite(vb))
            return va == vb;                // final check is for sign bits same
        if (is_nan(va) || is_nan(vb))
            return false;
    }

    int const   close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
    if ((va & 0x7FFFFFFF) == 0)
        return (vb & 0x7FFFFFFF) < close_to_zero;
    else if ((vb & 0x7FFFFFFF) == 0)
        return (va & 0x7FFFFFFF) < close_to_zero;

    uint32_t    sign_mask = va ^ vb;
    (int32_t &)sign_mask >>= 31;

    int32_t     diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb; 
    int32_t     v1 = tolerance + diff;
    int32_t     v2 = tolerance - diff;
    return (v1|v2) >= 0;
}

HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
    int32_t     va[2], vb[2];
    memcpy (va, &a, sizeof(double));
    memcpy (vb, &b, sizeof(double));

    if (is_special(va) || is_special(vb)) {
        if (is_infinite(va) || is_infinite(vb))
            return va[High] == vb[High] && va[Low] == vb[Low];  // final check is for sign bits same
        if (is_nan(va) || is_nan(vb))
            return false;
    }

    if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
        return Abs(a - b) < 0.000000000000005;

    if (extract_sign_bit(a) != extract_sign_bit(b))
        return a == b; //-V550

    if (va[High] != vb[High])
        return false;

    return Abs(va[Low] - vb[Low]) <= tolerance;
}



HPS_INLINE bool Is_Abnormal (float const & f)   { return Float::IsAbnormal (f); }
HPS_INLINE bool Is_Abnormal (double const & d)  { return Float::IsAbnormal (d); }

template <typename T>
HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
    while (count-- > 0)
        if (Is_Abnormal (*t++))
            return true;
    return false;
}

template <typename T>
HPS_INLINE bool Is_Abnormal (int count, T const * t) {
    return count >= 0 && Is_Abnormal((size_t)count, t);
}




template <typename F> class HPS_TEMPLATE_API Vector_3D;
template <typename F> class HPS_TEMPLATE_API Plane_3D;
template <typename F> class HPS_TEMPLATE_API Vector_2D;
template <typename F> class HPS_TEMPLATE_API Point_2D;


template <typename F>
class HPS_TEMPLATE_API Point_3D {
    public:
        F   x;
        F   y;
        F   z;

        Point_3D () {}
        Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}

        template <typename D>
        explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}

        explicit Point_3D (Vector_3D<F> const & v);
        explicit Point_3D (Vector_2D<F> const & v);
        explicit Point_3D (Point_2D<F> const & that);

        Point_3D const  operator- () const  { return Point_3D (-x, -y, -z); }

        bool                operator== (Point_3D const & p) const   { return  x == p.x && y == p.y && z == p.z; }
        bool                operator!= (Point_3D const & p) const   { return  !(*this == p); }

        bool                Equals(Point_3D const & p, int in_tolerance = 32) const {
                                return Float::Equals(x, p.x, in_tolerance) &&
                                        Float::Equals(y, p.y, in_tolerance) &&
                                        Float::Equals(z, p.z, in_tolerance);
                            }


        Point_3D &          operator*= (F s)        { x *= s; y *= s; z *= s;  return *this; }
        Point_3D &          operator/= (F s)        { return operator*= ((F)1 / s); }
        Point_3D const      operator* (F s) const   { return Point_3D (x * s, y * s, z * s); }
        Point_3D const      operator/ (F s) const   { return operator* ((F)1 / s); }

        F &                 operator[] (size_t i)       { return (&x)[i]; }
        F const &           operator[] (size_t i) const { return (&x)[i]; }

        Point_3D &          operator+= (Vector_3D<F> const & v);
        Point_3D &          operator-= (Vector_3D<F> const & v);
        Point_3D &          operator*= (Vector_3D<F> const & v);
        Point_3D &          operator/= (Vector_3D<F> const & v);
        Point_3D const      operator* (Vector_3D<F> const & v) const;
        Point_3D const      operator/ (Vector_3D<F> const & v) const;

        Point_3D &          operator+= (Vector_2D<F> const & v);
        Point_3D &          operator-= (Vector_2D<F> const & v);
        Point_3D &          operator*= (Vector_2D<F> const & v);
        Point_3D &          operator/= (Vector_2D<F> const & v);
        Point_3D const      operator* (Vector_2D<F> const & v) const;
        Point_3D const      operator/ (Vector_2D<F> const & v) const;

        Vector_3D<F> const  operator- (Point_3D const & p) const;

        Point_3D const      operator+ (Vector_3D<F> const & v) const;
        Point_3D const      operator- (Vector_3D<F> const & v) const;

        Point_3D const      operator+ (Vector_2D<F> const & v) const;
        Point_3D const      operator- (Vector_2D<F> const & v) const;

        static HPS_INLINE Point_3D  Origin() {return Point_3D (0, 0, 0);};
        static HPS_INLINE Point_3D  Zero() {return Point_3D (0, 0, 0);}; //-V524
};

typedef Point_3D<float> Point;
typedef Point_3D<double> DPoint;



template <typename F, typename S>
HPS_INLINE Point_3D<F>  operator* (S s, Point_3D<F> const & a) { return Point_3D<F> (F(s * a.x), F(s * a.y), F(s * a.z)); }

template <typename F>
HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
    return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
}

template <typename F>
HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
    return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
}

template <typename F>
HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
    return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
}


template <typename F>
class HPS_TEMPLATE_API Point_2D {
public:
    F   x;
    F   y;

    Point_2D () {}
    Point_2D (F v1, F v2) : x (v1), y (v2) {}

    template <typename D>
    explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}

    explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
    explicit Point_2D (Vector_2D<F> const & v);

    Point_2D const  operator- () const  { return Point_2D (-x, -y); }

    bool                operator== (Point_2D const & p) const   { return  x == p.x && y == p.y; }
    bool                operator!= (Point_2D const & p) const   { return  !(*this == p); }

    bool                Equals(Point_2D const & p, int in_tolerance = 32) const {
        return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
    }


    Point_2D &          operator*= (F s)        { x *= s; y *= s; return *this; }
    Point_2D &          operator/= (F s)        { return operator*= ((F)1 / s); }
    Point_2D const      operator* (F s) const   { return Point_2D (x * s, y * s); }
    Point_2D const      operator/ (F s) const   { return operator* ((F)1 / s); }

    F &                 operator[] (size_t i)       { return (&x)[i]; }
    F const &           operator[] (size_t i) const { return (&x)[i]; }

    Point_2D &          operator+= (Vector_2D<F> const & v);
    Point_2D &          operator-= (Vector_2D<F> const & v);
    Point_2D &          operator*= (Vector_2D<F> const & v);
    Point_2D &          operator/= (Vector_2D<F> const & v);
    Point_2D const      operator* (Vector_2D<F> const & v) const;
    Point_2D const      operator/ (Vector_2D<F> const & v) const;

    Vector_2D<F> const  operator- (Point_2D const & p) const;

    Point_2D const      operator+ (Vector_2D<F> const & v) const;
    Point_2D const      operator- (Vector_2D<F> const & v) const;

    static HPS_INLINE Point_2D  Origin() {return Point_2D (0, 0);};
    static HPS_INLINE Point_2D  Zero() {return Point_2D (0, 0);}; //-V524
};

typedef Point_2D<float> Point2D;
typedef Point_2D<double> DPoint2D;

template <typename F>
HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}

template <typename F, typename S>
HPS_INLINE Point_2D<F>  operator* (S s, Point_2D<F> const & a) { return Point_2D<F> (F(s * a.x), F(s * a.y)); }

template <typename F>
HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
    return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
}

template <typename F>
HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
    return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
}

template <typename F>
HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
    return Is_Abnormal (p.x) || Is_Abnormal (p.y);
}


template <typename F>
class HPS_TEMPLATE_API Vector_3D {
    public:
        F   x;
        F   y;
        F   z;

        Vector_3D () {}
        Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
        template <typename D>
            explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
        explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
        explicit Vector_3D(Plane_3D<F> const & p);

        explicit Vector_3D (Vector_2D<F> const & that);

        Vector_3D const operator- () const  { return Vector_3D (-x, -y, -z); }

        bool                operator== (Vector_3D const & v) const      {
                                return  Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
                            }
        bool                operator!= (Vector_3D const & v) const      { return  !(*this == v); }

        bool                Equals(Vector_3D const & v, int in_tolerance = 32) const {
                                return Float::Equals(x, v.x, in_tolerance) &&
                                        Float::Equals(y, v.y, in_tolerance) &&
                                        Float::Equals(z, v.z, in_tolerance);
                            }

        Vector_3D &         operator+= (Vector_3D const & v)        { x += v.x; y += v.y; z += v.z;  return *this; }
        Vector_3D &         operator-= (Vector_3D const & v)        { x -= v.x; y -= v.y; z -= v.z;  return *this; }
        Vector_3D const     operator+ (Vector_3D const & v) const   { return Vector_3D (x + v.x, y + v.y, z + v.z); }
        Vector_3D const     operator- (Vector_3D const & v) const   { return Vector_3D (x - v.x, y - v.y, z - v.z); }

        Vector_3D &         operator*= (F s)                { x *= s; y *= s; z *= s;  return *this; }
        Vector_3D &         operator/= (F s)                { return operator*= (1.0f / s); }
        Vector_3D const     operator* (F s) const           { return Vector_3D (x * s, y * s, z * s); }
        Vector_3D const     operator/ (F s) const           { return operator* (1.0f / s); }

        F &                 operator[] (size_t i)       { return (&x)[i]; }
        F const &           operator[] (size_t i) const { return (&x)[i]; }

        HPS_INLINE double   Length () const { return sqrt (LengthSquared()); }

        HPS_INLINE double   LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }

        HPS_INLINE double   Length2D () const { return sqrt (LengthSquared2D()); }

        HPS_INLINE double   LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}

        HPS_INLINE Vector_3D &  Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
            if (check_range) {
                F   range = Max (Abs (x), Abs (y), Abs (z));
                if (range > F(1.0e10))
                    operator/= (range);
            }

            F   len = (F)Length();
            if (len > epsilon)
                operator/= (len);
            else
                *this = Zero();
            return *this;
        }
        HPS_INLINE Vector_3D &  Normalize (F epsilon) { return Normalize (false, epsilon); }

        HPS_INLINE Vector_3D &  Clean_Zeroes (F epsilon = F(1.0e-4)) {
            if (Abs(x) < epsilon)
                x = 0;
            if (Abs(y) < epsilon)
                y = 0;
            if (Abs(z) < epsilon)
                z = 0;
            return *this;
        }

        HPS_INLINE F        Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
        HPS_INLINE F        Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }

        HPS_INLINE F        Dot (Vector_3D const & v) const { return x * v.x  +  y * v.y  +  z * v.z; }

        HPS_INLINE Vector_3D    Cross (Vector_3D const & v) const {
                                    return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
                                }


        HPS_INLINE Vector_3D    Scale (Vector_3D const & v) const {
                                    return Vector_3D (x * v.x, y * v.y, z * v.z);
                                }

        Vector_3D<F> different_vector () const {
            if (Abs (x) < Abs (y))
                return Vector_3D<F>::XAxis();
            else
                return Vector_3D<F>::YAxis();
        }


        static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
        static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
        static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
        static HPS_INLINE Vector_3D Zero()  {return Vector_3D (0, 0, 0);};
        static HPS_INLINE Vector_3D Unit()  {return Vector_3D (1, 1, 1);};
};

typedef Vector_3D<float> Vector;
typedef Vector_3D<double> DVector;


template <typename F, typename S>
HPS_INLINE  Vector_3D<F>    operator* (S s, Vector_3D<F> const & v) {return Vector_3D<F> (F(s * v.x), F(s * v.y), F(s * v.z)); }

template <typename F>
HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
    return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
}


template <typename F>
HPS_INLINE  Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}

template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator+= (Vector_3D<F> const & v)    { x += v.x; y += v.y; z += v.z;  return *this; }
template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator-= (Vector_3D<F> const & v)    { x -= v.x; y -= v.y; z -= v.z;  return *this; }

template <typename F>
HPS_INLINE  Vector_3D<F> const  Point_3D<F>::operator- (Point_3D<F> const & p) const    { return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }

template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator+ (Vector_3D<F> const & v) const   { return Point_3D<F>  (x + v.x, y + v.y, z + v.z); }
template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator- (Vector_3D<F> const & v) const   { return Point_3D<F>  (x - v.x, y - v.y, z - v.z); }

template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator*= (Vector_3D<F> const & v) { x *= v.x; y *= v.y; z *= v.z;  return *this; }
template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator/= (Vector_3D<F> const & v) { x /= v.x; y /= v.y; z /= v.z;  return *this; }
template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator* (Vector_3D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator/ (Vector_3D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z / v.z); }



template <typename F>
HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
    return a + (b - a) * t;
}

template <typename F>
HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
    return Vector_3D<F>(a + (b - a) * t).Normalize();
}



template <typename F>
HPS_INLINE  double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
    return (p2 - p1).Length();
}

template <typename F>
HPS_INLINE  double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
    return (p2 - p1).LengthSquared();
}

template <typename F>
HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
    F   p = static_cast<F>((c - b).LengthSquared());
    F   q = static_cast<F>((c - a).LengthSquared());
    F   r = static_cast<F>((b - a).LengthSquared());

    return Point_3D<F>(
        (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
            / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
}



template <typename F>
HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
    bool success = true;
    for (size_t i = 0; i < count; ++i) {
        if (vectors->Normalize() == Vector_3D<F>::Zero())
            success = false;
        vectors++;
    }
    return success;
}


template <typename F> class HPS_TEMPLATE_API Plane_2D;

template <typename F>
class HPS_TEMPLATE_API Vector_2D {
public:
    F   x;
    F   y;

    Vector_2D () {}
    Vector_2D (F v1, F v2) : x (v1), y (v2) {}
    template <typename D>
    explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}

    explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
    explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
    explicit Vector_2D (Plane_2D<F> const & p);

    Vector_2D const operator- () const  { return Vector_2D (-x, -y); }

    bool                operator== (Vector_2D const & v) const      {
        return  Float::match(x, v.x) && Float::match(y, v.y);
    }
    bool                operator!= (Vector_2D const & v) const      { return  !(*this == v); }

    bool                Equals(Vector_2D const & v, int in_tolerance = 32) const {
        return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
    }

    Vector_2D &         operator+= (Vector_2D const & v)        { x += v.x; y += v.y; return *this; }
    Vector_2D &         operator-= (Vector_2D const & v)        { x -= v.x; y -= v.y; return *this; }
    Vector_2D const     operator+ (Vector_2D const & v) const   { return Vector_2D (x + v.x, y + v.y); }
    Vector_2D const     operator- (Vector_2D const & v) const   { return Vector_2D (x - v.x, y - v.y); }

    Vector_2D &         operator*= (F s)                { x *= s; y *= s; return *this; }
    Vector_2D &         operator/= (F s)                { return operator*= (1.0f / s); }
    Vector_2D const     operator* (F s) const           { return Vector_2D (x * s, y * s); }
    Vector_2D const     operator/ (F s) const           { return operator* (1.0f / s); }

    F &                 operator[] (size_t i)       { return (&x)[i]; }
    F const &           operator[] (size_t i) const { return (&x)[i]; }

    HPS_INLINE double   Length () const { return sqrt (LengthSquared()); }

    HPS_INLINE double   LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }

    HPS_INLINE Vector_2D &  Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
        if (check_range) {
            F   range = Max (Abs (x), Abs (y));
            if (range > F(1.0e10))
                operator/= (range);
        }

        F   len = (F)Length();
        if (len > epsilon)
            operator/= (len);
        else
            *this = Zero();
        return *this;
    }
    HPS_INLINE Vector_2D &  Normalize (F epsilon) { return Normalize (false, epsilon); }

    HPS_INLINE F        Magnitude () const { return Max (Abs(x), Abs(y)); }
    HPS_INLINE F        Manhattan () const { return Abs(x)+Abs(y); }

    HPS_INLINE F        Dot (Vector_2D const & v) const { return x * v.x  +  y * v.y; }


    HPS_INLINE F        Cross (Vector_2D const & v) const {
        return x * v.y - y * v.x;
    }

    HPS_INLINE Vector_2D    Scale (Vector_2D const & v) const {
        return Vector_2D (x * v.x, y * v.y);
    }

    static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
    static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};

    static HPS_INLINE Vector_2D Zero()  {return Vector_2D (0, 0);};
    static HPS_INLINE Vector_2D Unit()  {return Vector_2D (1, 1);};
};

typedef Vector_2D<float> Vector2D;
typedef Vector_2D<double> DVector2D;

template <typename F, typename S>
HPS_INLINE  Vector_2D<F>    operator* (S s, Vector_2D<F> const & v) {return Vector_2D<F> (F(s * v.x), F(s * v.y)); }

template <typename F>
HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {      
    return Is_Abnormal (v.x) || Is_Abnormal (v.y);
}


template <typename F>
HPS_INLINE  Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}

template <typename F>
HPS_INLINE  Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}

template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator+= (Vector_2D<F> const & v)    { x += v.x; y += v.y; return *this; }
template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator-= (Vector_2D<F> const & v)    { x -= v.x; y -= v.y; return *this; }

template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator+ (Vector_2D<F> const & v) const   { return Point_3D<F>  (x + v.x, y + v.y, z); }
template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator- (Vector_2D<F> const & v) const   { return Point_3D<F>  (x - v.x, y - v.y, z); }

template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
template <typename F>
HPS_INLINE  Point_3D<F> &       Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }

template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator* (Vector_2D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z); }
template <typename F>
HPS_INLINE  Point_3D<F> const   Point_3D<F>::operator/ (Vector_2D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z); }


template <typename F>
HPS_INLINE  Point_2D<F> &       Point_2D<F>::operator+= (Vector_2D<F> const & v)    { x += v.x; y += v.y; return *this; }
template <typename F>
HPS_INLINE  Point_2D<F> &       Point_2D<F>::operator-= (Vector_2D<F> const & v)    { x -= v.x; y -= v.y; return *this; }

template <typename F>
HPS_INLINE  Vector_2D<F> const  Point_2D<F>::operator- (Point_2D<F> const & p) const    { return Vector_2D<F> (x - p.x, y - p.y); }

template <typename F>
HPS_INLINE  Point_2D<F> const   Point_2D<F>::operator+ (Vector_2D<F> const & v) const   { return Point_2D<F>  (x + v.x, y + v.y); }
template <typename F>
HPS_INLINE  Point_2D<F> const   Point_2D<F>::operator- (Vector_2D<F> const & v) const   { return Point_2D<F>  (x - v.x, y - v.y); }

template <typename F>
HPS_INLINE  Point_2D<F> &       Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
template <typename F>
HPS_INLINE  Point_2D<F> &       Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
template <typename F>
HPS_INLINE  Point_2D<F> const   Point_2D<F>::operator* (Vector_2D<F> const & v) const { return Point_2D<F> (x * v.x, y * v.y); }
template <typename F>
HPS_INLINE  Point_2D<F> const   Point_2D<F>::operator/ (Vector_2D<F> const & v) const { return Point_2D<F> (x / v.x, y / v.y); }





template <typename F>
class HPS_TEMPLATE_API Plane_3D {
    public:
        F   a;
        F   b;
        F   c;
        F   d;

        Plane_3D () {}
        Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
        Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
        Plane_3D (Vector_3D<F> const & v, Point_3D<F> const & p) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
        Plane_3D (Point_3D<F> const & p, Vector_3D<F> const & v) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
        template <typename D>
            explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}

        Plane_3D (size_t count, Point_3D<F> const * points) {
            if (count >= 3) {
                // The 3 coefficients A, B, and C are proportional to the areas of the
                // projections of the polygon onto the yz, zx, and xy planes, respectively.

                // run around the polygon, collecting trapezoidal areas
                // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.

                // take care of the swing point first
                Point_3D<F> const * p0 = &points[count-1];

                Point_3D<double>    ctr = Point_3D<double>::Origin();
                Vector_3D<F>        normal = Vector_3D<F>::Zero();

                for (size_t i=0; i<count; ++i) {
                    Point_3D<F> const * p1 = &points[i];

                    normal.x += (p0->y + p1->y) * (p1->z - p0->z);
                    normal.y += (p0->z + p1->z) * (p1->x - p0->x);
                    normal.z += (p0->x + p1->x) * (p1->y - p0->y);

                    ctr += Vector_3D<double>(Vector_3D<F>(points[i]));

                    p0 = p1;
                }

                // ("should" always be != 0)
                if (normal.Normalize() != Vector_3D<F>::Zero()) {
                    /* finish finding the average */
                    double  inv_count = 1.0 / (double)count;
                    ctr *= inv_count;

                    *this = Plane_3D(normal, Point_3D<F>(ctr));
                    return;
                }
            }

            *this = Plane_3D::Zero();
        }


        Plane_3D const      operator- () const                          { return Plane_3D (-a, -b, -c, -d); }

        bool                operator== (Plane_3D const & p) const       { return  a == p.a && b == p.b && c == p.c && d == p.d; }
        bool                operator!= (Plane_3D const & p) const       { return  !(*this == p); }

        F &                 operator[] (size_t i)       { return (&a)[i]; }
        F const &           operator[] (size_t i) const { return (&a)[i]; }

        HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const { 
            return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && 
                    Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
        }

        Plane_3D &      Normalize (F epsilon = Float_Traits<F>::Epsilon()) {    // not const &; allow V.normalize() *= S;
            F len = (F)Vector_3D<F>(*this).Length();
            if (len > epsilon)
                operator/= (len);
            else
                *this = Zero();
            return *this;
        }

        Point_3D<F>     IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
            F   val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
            F   val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);

            if (val1 >= eps) {
                return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
                                    ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
                                    ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
            }
            else
                return p1;
        }

        Point_3D<F>     IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
            F        u = (a * p1.x + b * p1.y + c * p1.z + d) /
                        (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));

            return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
        }


        bool parallel (Plane_3D const & p) const {
            return  equivalent (a, p.a) &&
                    equivalent (b, p.b) &&
                    equivalent (c, p.c);
        }

        bool equivalent (Plane_3D const & p) const {
            return  parallel (p) &&
                    equivalent (d, p.d, (F)1.0e-6);
        }


        static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};


    private:
        Plane_3D &      operator*= (F s)                { a *= s; b *= s; c *= s; d *= s; return *this; }
        Plane_3D &      operator/= (F s)                { return operator*= ((F)1.0 / s); }
        Plane_3D const  operator* (F s) const           { return Plane_3D (a * s, b * s, c * s, d * s); }
        Plane_3D const  operator/ (F s) const           { return operator* ((F)1.0 / s); }

        static bool equivalent (float a, float b) {                 // for vector components
            if (Abs(a) < 1.0e-4f && Abs(b) < 1.0e-4f)
                return true;
            return Float::Equals (a, b);
        }

        static bool equivalent (float a, float b, float cutoff) {   // for distance
            if (Abs(a) < cutoff && Abs(b) < cutoff)
                return a == b;
            return Float::Equals (a, b);
        }
};

typedef Plane_3D<float> Plane;
typedef Plane_3D<double> DPlane;


template <typename F>
HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
    return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
}


template <typename F>
HPS_INLINE  F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
    return plane.a * point.x  +  plane.b * point.y  +  plane.c * point.z  +  plane.d;
}
template <typename F>
HPS_INLINE  F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
    return plane * point;
}

template <typename F>
HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
    return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
}

template <typename F>
Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}






template <typename F>
class HPS_TEMPLATE_API Plane_2D {
public:
    F   a;
    F   b;
    F   c;

    Plane_2D () {}
    Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
    Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
    Plane_2D (Vector_2D<F> const & v, Point_2D<F> const & p) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
    Plane_2D (Point_2D<F> const & p, Vector_2D<F> const & v) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
    template <typename D>
    explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}

    Plane_2D const      operator- () const                          { return Plane_2D (-a, -b, -c); }

    bool                operator== (Plane_2D const & p) const       { return  a == p.a && b == p.b && c == p.c; }
    bool                operator!= (Plane_2D const & p) const       { return  !(*this == p); }

    F &                 operator[] (size_t i)       { return (&a)[i]; }
    F const &           operator[] (size_t i) const { return (&a)[i]; }

    HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const { 
        return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance); 
    }

    Plane_2D &      Normalize (F epsilon = Float_Traits<F>::Epsilon()) {    // not const &; allow V.Normalize() *= S;
        F len = (F)Vector_2D<F>(*this).Length();
        if (len > epsilon)
            operator/= (len);
        else
            *this = Zero();
        return *this;
    }

    static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};


private:
    Plane_2D &      operator*= (F s)                { a *= s; b *= s; c *= s; return *this; }
    Plane_2D &      operator/= (F s)                { return operator*= ((F)1.0 / s); }
    Plane_2D const  operator* (F s) const           { return Plane_2D (a * s, b * s, c * s); }
    Plane_2D const  operator/ (F s) const           { return operator* ((F)1.0 / s); }
};

typedef Plane_2D<float> Plane2D;
typedef Plane_2D<double> DPlane2D;


template <typename F>
HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
    return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
}


template <typename F>
HPS_INLINE  F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) { 
    return plane.a * point.x + plane.b * point.y + plane.c;
}
template <typename F>
HPS_INLINE  F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
    return plane * point;
}

template <typename F>
HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
    return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
}

template <typename F>
Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}




struct Rectangle;

struct HPS_API IntRectangle {
    int left;
    int right;
    int bottom;
    int top;

    IntRectangle()
        : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
          bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}

    IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
        : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}

    IntRectangle(IntRectangle const & that)
        : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}

    explicit IntRectangle(Rectangle const & that);

    bool operator==(IntRectangle const & rect) const {
        return  (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
    }

    bool operator!=(IntRectangle const & rect) const {
        return  !(*this == rect);
    }

    HPS_INLINE int PixelWidth() const {
        return right - left + 1;
    }

    HPS_INLINE int PixelHeight() const {
        return top - bottom + 1;
    }

    HPS_INLINE int Width() const {
        return right - left;
    }

    HPS_INLINE int Height() const {
        return top - bottom;
    }

    HPS_INLINE int Area() const {
        return Width() * Height();
    }

    HPS_INLINE float Aspect() const {
        return  (float)Height() / (float)Width();
    }

    HPS_INLINE Point2D Center() const {
        return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
    }

    HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
        return  right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
    }

    HPS_INLINE bool Contains(IntRectangle const & rect) const {
        return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
    }

    HPS_INLINE IntRectangle & Expand(int border) {
        left -= border;
        right += border;
        bottom -= border;
        top += border;
        return *this;
    }

    HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
        left -= rect.left;
        right += rect.right;
        bottom -= rect.bottom;
        top += rect.top;
        return *this;
    }

    HPS_INLINE IntRectangle & Contract(int border) {
        left += border;
        right -= border;
        bottom += border;
        top -= border;
        return *this;
    }

    HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
        left += rect.left;
        right -= rect.right;
        bottom += rect.bottom;
        top -= rect.top;
        return *this;
    }

    HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
        left = Max(left, rect.left);
        right = Min(right, rect.right);
        bottom = Max(bottom, rect.bottom);
        top = Min(top, rect.top);
        return *this;
    }

    HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
        left = Min(left, rect.left);
        right = Max(right, rect.right);
        bottom = Min(bottom, rect.bottom);
        top = Max(top, rect.top);
        return *this;
    }


    static HPS_INLINE IntRectangle Invalid() {
        return IntRectangle();
    }

    static HPS_INLINE IntRectangle Zero() {
        return IntRectangle(0, 0, 0, 0);
    }

};

HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
    IntRectangle temp = a;
    return temp.Expand(border);
}

HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
    IntRectangle temp = a;
    return temp.Expand(border);
}

HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
    IntRectangle temp = a;
    return temp.Contract(border);
}

HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
    IntRectangle temp = a;
    return temp.Contract(border);
}

HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
    IntRectangle temp = a;
    return temp.Intersect(b);
}

HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
    IntRectangle temp = a;
    return temp.Union(b);
}

struct HPS_API Rectangle {
    float   left;
    float   right;
    float   bottom;
    float   top;

    Rectangle()
        : left(std::numeric_limits<float>::max()), right(-std::numeric_limits<float>::max()),
          bottom(std::numeric_limits<float>::max()), top(-std::numeric_limits<float>::max()) {}

    Rectangle(float in_left, float in_right, float in_bottom, float in_top)
        : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}

    Rectangle(Rectangle const & that) 
        : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}

    explicit Rectangle(IntRectangle const & that)
        : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}

    HPS_INLINE  Rectangle(size_t count, Point const * points) {
        left = points->x;
        right = points->x;
        top = points->y;
        bottom = points->y;
        --count;
        if (count > 0) {
            ++points;
            Merge(count, points);
        }
    }

    HPS_INLINE  Rectangle(size_t count, Point2D const * points) {
        left = points->x;
        right = points->x;
        top = points->y;
        bottom = points->y;
        --count;
        if (count > 0) {
            ++points;
            Merge(count, points);
        }
    }

    HPS_INLINE float Width() const {
        return right - left;
    }

    HPS_INLINE float Height() const {
        return top - bottom;
    }

    HPS_INLINE float Area() const {
        return Width() * Height();
    }

    HPS_INLINE float Aspect() const {
        return  Height() / Width();
    }

    HPS_INLINE Point2D Center() const {
        return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
    }

    HPS_INLINE void Merge(size_t count, Point const * points) {

        while (count > 1) {
            if (points[0].x > points[1].x) {
                Float::replace_if_smaller(left, points[1].x);
                Float::replace_if_larger(right, points[0].x);
            }
            else {
                Float::replace_if_smaller(left, points[0].x);
                Float::replace_if_larger(right, points[1].x);
            }

            if (points[0].y > points[1].y) {
                Float::replace_if_smaller(bottom, points[1].y);
                Float::replace_if_larger(top, points[0].y);
            }
            else {
                Float::replace_if_smaller(bottom, points[0].y);
                Float::replace_if_larger(top, points[1].y);
            }

            points += 2;
            count -= 2;
        }

        if (count > 0)
            Merge(*points);
    }

    HPS_INLINE void Merge(Point const & point)  {
        Float::replace_if_smaller(left, point.x);
        Float::replace_if_smaller(bottom, point.y);
        Float::replace_if_larger(right, point.x);
        Float::replace_if_larger(top, point.y);
    }

    HPS_INLINE void Merge(size_t count, Point2D const * points) {

        while (count > 1) {
            if (points[0].x > points[1].x) {
                Float::replace_if_smaller(left, points[1].x);
                Float::replace_if_larger(right, points[0].x);
            }
            else {
                Float::replace_if_smaller(left, points[0].x);
                Float::replace_if_larger(right, points[1].x);
            }

            if (points[0].y > points[1].y) {
                Float::replace_if_smaller(bottom, points[1].y);
                Float::replace_if_larger(top, points[0].y);
            }
            else {
                Float::replace_if_smaller(bottom, points[0].y);
                Float::replace_if_larger(top, points[1].y);
            }

            points += 2;
            count -= 2;
        }

        if (count > 0)
            Merge(*points);
    }

    HPS_INLINE void Merge(Point2D const & point)    {
        Float::replace_if_smaller(left, point.x);
        Float::replace_if_smaller(bottom, point.y);
        Float::replace_if_larger(right, point.x);
        Float::replace_if_larger(top, point.y);
    }

    HPS_INLINE bool operator==(Rectangle const & rect) const {
        return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
    }

    HPS_INLINE bool operator!=(Rectangle const & rect) const {
        return  !(*this == rect);
    }

    HPS_INLINE bool Equals(Rectangle const & rect, int in_tolerance = 32) const {
        return Float::Equals(left, rect.left, in_tolerance) &&
            Float::Equals(right, rect.right, in_tolerance) &&
            Float::Equals(top, rect.top, in_tolerance) &&
            Float::Equals(bottom, rect.bottom, in_tolerance);
    }

    HPS_INLINE bool Intersecting(Rectangle const & rect) const {
        return  right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
    }

    HPS_INLINE bool Contains(Point const & contained) const {
        return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
    }

    HPS_INLINE bool Contains(Point2D const & contained) const {
        return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
    }

    HPS_INLINE bool Contains(Rectangle const & rect) {
        return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
    }

    HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
        return (left <= rect.left + epsilon && right >= rect.right - epsilon && 
                bottom <= rect.bottom + epsilon && top >= rect.top  - epsilon);
    }

    HPS_INLINE Rectangle & Expand(float border) {
        left -= border;
        right += border;
        bottom -= border;
        top += border;
        return *this;
    }

    HPS_INLINE Rectangle & Expand(int border) {
        Expand((float)border);
        return *this;
    }

    HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
        left -= rect.left;
        right += rect.right;
        bottom -= rect.bottom;
        top += rect.top;
        return *this;
    }

    HPS_INLINE Rectangle & Contract(int border) {
        left += border;
        right -= border;
        bottom += border;
        top -= border;
        return *this;
    }

    HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
        left += rect.left;
        right -= rect.right;
        bottom += rect.bottom;
        top -= rect.top;
        return *this;
    }

    HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
        left = Max(left, rect.left);
        right = Min(right, rect.right);
        bottom = Max(bottom, rect.bottom);
        top = Min(top, rect.top);
        return *this;
    }

    HPS_INLINE Rectangle & Union(Rectangle const & rect) {
        left = Min(left, rect.left);
        right = Max(right, rect.right);
        bottom = Min(bottom, rect.bottom);
        top = Max(top, rect.top);
        return *this;
    }

    HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
        float scale = (scope.right - scope.left) * 0.5f;
        float trans = (scope.right + scope.left) * 0.5f;

        left = left * scale + trans;
        right = right * scale + trans;

        scale = (scope.top - scope.bottom) * 0.5f;
        trans = (scope.top + scope.bottom) * 0.5f;

        bottom = bottom * scale + trans;
        top = top * scale + trans;
        return *this;
    }

    HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
        float tmp = 2.0f/(scope.right - scope.left);
        right = (right - scope.left) * tmp - 1.0f;
        left = (left - scope.left) * tmp - 1.0f;

        tmp = 2.0f/(scope.top - scope.bottom);
        top = (top - scope.bottom) * tmp - 1.0f;
        bottom = (bottom - scope.bottom) * tmp - 1.0f;
        return *this;
    }

    static HPS_INLINE Rectangle FullScope() {
        return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
    }

    static HPS_INLINE Rectangle InvalidScope() {
        return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
    }

    static HPS_INLINE Rectangle Zero() {
        return Rectangle(0, 0, 0, 0);
    }

};


HPS_INLINE IntRectangle Floor(Rectangle const & a) {
    IntRectangle temp;
    temp.left = Floor (a.left);
    temp.right = Floor (a.right);
    temp.bottom = Floor (a.bottom);
    temp.top = Floor (a.top);
    return temp;
}

HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
    Rectangle temp = a;
    return temp.Expand(border);
}

HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
    Rectangle temp = a;
    return temp.Expand(border);
}

HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
    Rectangle temp = a;
    return temp.Contract(border);
}

HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
    Rectangle temp = a;
    return temp.Contract(border);
}

HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
    Rectangle temp = a;
    return temp.Intersect(b);
}

HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
    Rectangle temp = a;
    return temp.Union(b);
}

HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
    Rectangle temp = a;
    return temp.Inscribe_Scope(scope);
}

HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
    Rectangle temp = a;
    return temp.Circumscribe_Scope(scope);
}

HPS_INLINE  IntRectangle::IntRectangle(Rectangle const & that)
    : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}




template <typename F>
struct Sphere_3D;

template <typename F>
struct HPS_TEMPLATE_API Cuboid_3D {
    Point_3D<F> min;
    Point_3D<F> max;


    Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}

    
    template <typename D>
    explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}


    Cuboid_3D (Sphere_3D<F> const & that);

    Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}

    Cuboid_3D (size_t count, Point_3D<F> const * points) {
        if (count == 0) {
            min = Limit_Point();
            max = -Limit_Point();
            return;
        }
        min = max = *points++;
        if (--count > 0)
            Merge(count, points);
    }

    template <typename T>
    Cuboid_3D (size_t count, T const * indices, Point_3D<F> const * points) {
        if (count == 0) {
            min = Limit_Point();
            max = -Limit_Point();
            return;
        }
        min = max = points[*indices++];
        if (--count > 0)
            Merge(count, indices, points);
    }

    Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}

    HPS_INLINE bool IsValid() const {
        return min.x <= max.x && min.y <= max.y && min.z <= max.z;
    }

    static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};

    void Invalidate() {min = Limit_Point(); max = -Limit_Point();}

    HPS_INLINE bool     operator== (Cuboid_3D const & cuboid) const { return  (min == cuboid.min && max == cuboid.max); }
    
    HPS_INLINE bool     operator!= (Cuboid_3D const & cuboid) const { return  !(*this == cuboid); }

    HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
        points[0] = Point_3D<F> (min.x, min.y, min.z);
        points[1] = Point_3D<F> (min.x, min.y, max.z);
        points[2] = Point_3D<F> (min.x, max.y, min.z);
        points[3] = Point_3D<F> (min.x, max.y, max.z);
        points[4] = Point_3D<F> (max.x, min.y, min.z);
        points[5] = Point_3D<F> (max.x, min.y, max.z);
        points[6] = Point_3D<F> (max.x, max.y, min.z);
        points[7] = Point_3D<F> (max.x, max.y, max.z);
    }

    HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }

    HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }

    HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
        return  max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
                max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
                max.z >= cuboid.min.z && min.z <= cuboid.max.z;
    }

    HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
        return  max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
                max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
                max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
    }

    HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
        //ASSERT (0 <= dimension && dimension <= 2);
        return  max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
    }

    HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
        //ASSERT (0 <= dimension && dimension <= 2);
        return  max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
    }

    HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
        return LineIntersecting(start, direction, true);
    }

    HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
        Vector_3D<F> const direction = point2 - point1;
        return LineIntersecting(point1, direction, false);
    }

    HPS_INLINE void Merge(Cuboid_3D const & cuboid)     {
        Float::replace_if_smaller(min.x, cuboid.min.x);
        Float::replace_if_smaller(min.y, cuboid.min.y);
        Float::replace_if_smaller(min.z, cuboid.min.z);
        Float::replace_if_larger(max.x, cuboid.max.x);
        Float::replace_if_larger(max.y, cuboid.max.y);
        Float::replace_if_larger(max.z, cuboid.max.z);
    }

    HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }

    HPS_INLINE void Merge(Point_3D<F> const & point)    {
        Float::replace_if_smaller(min.x, point.x);
        Float::replace_if_smaller(min.y, point.y);
        Float::replace_if_smaller(min.z, point.z);
        Float::replace_if_larger(max.x, point.x);
        Float::replace_if_larger(max.y, point.y);
        Float::replace_if_larger(max.z, point.z);
    }

    void Merge(size_t count, Point_3D<F> const * points)    {
        while (count > 1) {
            merge2(points[0], points[1]);
            points += 2;
            count -= 2;
        }

        if (count > 0)
            Merge(*points);
    }

    template <typename T>
    void Merge(size_t count, T const * indices, Point_3D<F> const * points)     {
        while (count > 1) {
            T       i1 = *indices++;
            T       i2 = *indices++;
            merge2(points[i1], points[i2]);
            count -= 2;
        }

        if (count > 0)
            Merge(points[*indices]);
    }

    HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
        return (contained.min.x >= min.x &&
                contained.min.y >= min.y &&
                contained.min.z >= min.z &&
                contained.max.x <= max.x &&
                contained.max.y <= max.y &&
                contained.max.z <= max.z);
    }

    HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
        return (contained.x >= min.x &&
                contained.y >= min.y &&
                contained.z >= min.z &&
                contained.x <= max.x &&
                contained.y <= max.y &&
                contained.z <= max.z);
    }

    HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
        return (contained.x >= min.x - epsilon &&
                contained.y >= min.y - epsilon &&
                contained.z >= min.z - epsilon &&
                contained.x <= max.x + epsilon &&
                contained.y <= max.y + epsilon &&
                contained.z <= max.z + epsilon);
    }

    HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid)  {
        Float::replace_if_larger(min.x, cuboid.min.x);
        Float::replace_if_larger(min.y, cuboid.min.y);
        Float::replace_if_larger(min.z, cuboid.min.z);
        Float::replace_if_smaller(max.x, cuboid.max.x);
        Float::replace_if_smaller(max.y, cuboid.max.y);
        Float::replace_if_smaller(max.z, cuboid.max.z);
        return *this;
    }

    HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid)  {
        Float::replace_if_smaller(min.x, cuboid.min.x);
        Float::replace_if_smaller(min.y, cuboid.min.y);
        Float::replace_if_smaller(min.z, cuboid.min.z);
        Float::replace_if_larger(max.x, cuboid.max.x);
        Float::replace_if_larger(max.y, cuboid.max.y);
        Float::replace_if_larger(max.z, cuboid.max.z);
        return *this;
    }

    HPS_INLINE Cuboid_3D & Expand(F border)  {
        Vector_3D<F>        delta (border, border, border);
        min -= delta;
        max += delta;
        return *this;
    }

    HPS_INLINE Cuboid_3D & Contract(F border)  {
        Vector_3D<F>        delta (border, border, border);
        min += delta;
        max -= delta;
        return *this;
    }

private:
    void merge2(Point_3D<F> const & p1, Point_3D<F> const & p2)     {
        if (p1.x > p2.x) {
            Float::replace_if_smaller(min.x, p2.x);
            Float::replace_if_larger(max.x, p1.x);
        }
        else {
            Float::replace_if_smaller(min.x, p1.x);
            Float::replace_if_larger(max.x, p2.x);
        }

        if (p1.y > p2.y) {
            Float::replace_if_smaller(min.y, p2.y);
            Float::replace_if_larger(max.y, p1.y);
        }
        else {
            Float::replace_if_smaller(min.y, p1.y);
            Float::replace_if_larger(max.y, p2.y);
        }

        if (p1.z > p2.z) {
            Float::replace_if_smaller(min.z, p2.z);
            Float::replace_if_larger(max.z, p1.z);
        }
        else {
            Float::replace_if_smaller(min.z, p1.z);
            Float::replace_if_larger(max.z, p2.z);
        }
    }

    HPS_INLINE static Point_3D<F> Limit_Point () {
        F const     x = std::numeric_limits<F>::max();
        return Point_3D<F> (x, x, x);
    }

    bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
};

typedef Cuboid_3D<float>    SimpleCuboid;
typedef Cuboid_3D<double>   DSimpleCuboid;


template <typename F>
HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
    Cuboid_3D<F> temp = a;
    return temp.Intersect(b);
}

template <typename F>
HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
    Cuboid_3D<F> temp = a;
    return temp.Union(b);
}

template <typename F>
HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
    Cuboid_3D<F> temp = a;
    return temp.Expand(border);
}

template <typename F>
HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
    Cuboid_3D<F> temp = a;
    return temp.Contract(border);
}



template <typename F>
struct HPS_TEMPLATE_API Sphere_3D {
    Point_3D<F>         center;
    F                   radius;

    Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(-1) {}

    template <typename D>
        explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}

    Sphere_3D (Cuboid_3D<F> const & cuboid) {
        if (cuboid.max.x < cuboid.min.x || cuboid.max.y < cuboid.min.y || cuboid.max.z < cuboid.min.z)
            *this = Invalid();
        else {
            center = Midpoint(cuboid.min, cuboid.max);
            radius = F(0.5 * cuboid.Diagonal().Length());
        }
    }

    Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}

    Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
        Cuboid_3D<F>    cuboid(count, points);
        center = Midpoint(cuboid.min, cuboid.max);
        Engulf (count, points);
    }

    template <typename T>
    Sphere_3D (size_t count, T const * indices, Point_3D<F> const * points) : radius(0.0f) {
        Cuboid_3D<F>    cuboid(count, indices, points);
        center = Midpoint(cuboid.min, cuboid.max);
        Engulf (count, indices, points);
    }

    Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center)
        : center(starting_center), radius(0) {
        Engulf (count, points);
    }

    template <typename T>
    Sphere_3D (size_t count, T const * indices, Point_3D<F> const * points, Point_3D<F> const & starting_center)
        : center(starting_center), radius(0) {
        Engulf (count, indices, points);
    }

    HPS_INLINE bool     IsValid() const {
        return radius >= 0;
    }

    static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};

    void Invalidate() {radius = -1;}

    HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return  (center == sphere.center && radius == sphere.radius); }
    HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return  !(*this == sphere); }

    HPS_INLINE F    Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }

    HPS_INLINE void Merge(Point_3D<F> const & point) {
        Vector_3D<F>    dir = point - center;
        F               distance = (F)dir.Length();

        if (distance > radius) {
            F   t = F(0.5) * (distance - radius);
            center += t * dir.Normalize();
            radius += t;
        }
    }

    HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
        F radius_squared = radius * radius;
        for (size_t i = 0; i < count; ++i) {
            Vector_3D<F>    dir = *points - center;
            F               distance_squared = (F)dir.LengthSquared();

            if (distance_squared > radius_squared) {
                F   distance = sqrt(distance_squared);
                F   t = F(0.5) * ( distance - radius);
                center += t * (distance > Float_Traits<F>::Epsilon() ? dir / distance : Vector_3D<F>::Zero());
                radius += t;
                radius_squared = radius * radius;
            }

            ++points;
        }
    }

    HPS_INLINE void Merge (Sphere_3D const & sphere) {
        Vector_3D<F>    dir = sphere.center - center;
        F               distance = (F)dir.Length();

        if (distance + sphere.radius > radius) {
            if (distance + radius > sphere.radius) {
                F       t = F(0.5 * (sphere.radius + distance - radius));
                center += t * dir.Normalize();
                radius += t;
            }
            else {
                center = sphere.center;
                radius = sphere.radius;
            }
        }
    }

    HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }

private:
    // Engulf expands the sphere to include the points, but does not change the center as Merge does
    HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
        double      rsq = radius * radius;
        for (size_t i = 0; i < count; ++i) {
            double  dsq = (*points++ - center).LengthSquared();
            if (dsq > rsq)
                rsq = dsq;
        }
        radius = (F)sqrt(rsq);
    }

    template <typename T>
    HPS_INLINE void Engulf (size_t count, T const * indices, Point_3D<F> const * points) {
        double      rsq = radius * radius;
        for (size_t i = 0; i < count; ++i) {
            double  dsq = (points[*indices++] - center).LengthSquared();
            if (dsq > rsq)
                rsq = dsq;
        }
        radius = (F)sqrt(rsq);
    }
};

typedef Sphere_3D<float>    SimpleSphere;
typedef Sphere_3D<double>   DSimpleSphere;


template <typename F>
HPS_INLINE  Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
    if (sphere.radius < 0)
        *this = Invalid();
    else {
        min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
        max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
    }
}




class RGB24Color;
class RGBA32Color;
class RGBAS32Color;
class RGBAColor;

class HPS_API RGBColor {
public:
    float   red;
    float   green;
    float   blue;

    HPS_INLINE RGBColor () {}
    HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
    explicit HPS_INLINE RGBColor (RGB24Color const & c24);
    explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
    explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
    explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
    explicit HPS_INLINE RGBColor (RGBAColor const & c);

    HPS_INLINE bool     IsGray() const {return (red == green && green == blue);}
    HPS_INLINE float    Gray() const { return  0.3125f * red  +  0.5000f * green  +  0.1875f * blue; }
    float Distance(RGBColor const & other_color) const;
    HPS_INLINE bool     IsValid() const {
        return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
    }

    HPS_INLINE bool operator== (RGBColor const & c) const   { return  red == c.red && green == c.green && blue == c.blue; }
    HPS_INLINE bool operator!= (RGBColor const & c) const   { return  !(*this == c); }

    HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
 { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }

    HPS_INLINE RGBColor &       operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue;  return *this; }
    HPS_INLINE RGBColor &       operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue;  return *this; }
    HPS_INLINE RGBColor &       operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue;  return *this; }
    HPS_INLINE RGBColor const   operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
    HPS_INLINE RGBColor const   operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
    HPS_INLINE RGBColor const   operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }

    HPS_INLINE RGBColor &       operator*= (float s) { red *= s; green *= s; blue *= s;  return *this; }
    HPS_INLINE RGBColor &       operator/= (float s) { return operator*= (1.0f / s); }
    HPS_INLINE RGBColor &       operator+= (float s) { red += s; green += s; blue += s;  return *this; }
    HPS_INLINE RGBColor &       operator-= (float s) { red -= s; green -= s; blue -= s;  return *this; }
    HPS_INLINE RGBColor const   operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
    HPS_INLINE RGBColor const   operator/ (float s) const { return operator* (1.0f / s); }
    HPS_INLINE RGBColor const   operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
    HPS_INLINE RGBColor const   operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }

    static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
    static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
    static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};

    void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
    void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
    void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;

    static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
    static RGBColor HSV(float in_hue, float in_saturation, float in_value);
    static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
};

HPS_INLINE  RGBColor const  operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
HPS_INLINE  RGBColor const  operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
HPS_INLINE  RGBColor const  operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }


class HPS_API RGBAColor {
public:
    
    float red; 
    float green; 
    float blue; 
    float alpha; 
    HPS_INLINE RGBAColor () {}
    explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
    HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}

    HPS_INLINE RGBAColor (RGBColor const & c) {
        memcpy(this, &c, sizeof(RGBColor)); //-V512
        alpha = 1.0f;
        Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
    }
    HPS_INLINE RGBAColor (RGBColor const & c, float a) {
        memcpy(this, &c, sizeof(RGBColor));
        memcpy(&alpha, &a, sizeof(float));
        Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
    }
    explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
    explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);

    HPS_INLINE bool     IsGray() const {return (red == green && green == blue);}
    HPS_INLINE float    Gray() const { return  0.3125f * red  +  0.5000f * green  +  0.1875f * blue; }
    HPS_INLINE bool     IsValid() const {
        return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
    }

    HPS_INLINE bool operator== (RGBAColor const & c) const      { return  red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }

    HPS_INLINE bool operator!= (RGBAColor const & c) const      { return  !(*this == c); }

    HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
        return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
                Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
    }

    HPS_INLINE RGBAColor &      operator*= (RGBAColor const & c)    { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
    HPS_INLINE RGBAColor &      operator+= (RGBAColor const & c)    { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
    HPS_INLINE RGBAColor &      operator-= (RGBAColor const & c)    { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
    HPS_INLINE RGBAColor const  operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
    HPS_INLINE RGBAColor const  operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
    HPS_INLINE RGBAColor const  operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }

    HPS_INLINE RGBAColor &      operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
    HPS_INLINE RGBAColor &      operator/= (float s) { return operator*= (1.0f / s); }
    HPS_INLINE RGBAColor &      operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
    HPS_INLINE RGBAColor &      operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
    HPS_INLINE RGBAColor const  operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
    HPS_INLINE RGBAColor const  operator/ (float s) const { return operator* (1.0f / s); }
    HPS_INLINE RGBAColor const  operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
    HPS_INLINE RGBAColor const  operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }

    HPS_INLINE RGBAColor &      operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
    HPS_INLINE RGBAColor &      operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
    HPS_INLINE RGBAColor &      operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
    HPS_INLINE RGBAColor const  operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
    HPS_INLINE RGBAColor const  operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
    HPS_INLINE RGBAColor const  operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }

    static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
    static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
    static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
    static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
};

HPS_INLINE  RGBAColor const operator* (float s, RGBAColor const & v) { return RGBAColor (s * v.red, s * v.green, s * v.blue, s * v.alpha); }
HPS_INLINE  RGBAColor const operator+ (float s, RGBAColor const & v) { return RGBAColor (s + v.red, s + v.green, s + v.blue, s + v.alpha); }
HPS_INLINE  RGBAColor const operator- (float s, RGBAColor const & v) { return RGBAColor (s - v.red, s - v.green, s - v.blue, s - v.alpha); }



struct DirectRGBColor {
public:
    enum Order {
        Order_ABGR,
        Order_RGBA,
        Order_BGRA
    };

#ifdef _MSC_VER
    HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
    unsigned char   b, g, r, a;
#endif

#ifdef __linux__
    HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
    unsigned char   r, g, b, a;
#endif

#ifdef __APPLE_CC__
    HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
    unsigned char   r, g, b, a;
#endif
};



class RGBAS32Color : public DirectRGBColor {
public:

    HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
    explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
        r = gray;
        g = gray;
        b = gray;
        a = aa;
    }
    HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
        r = rr;
        g = gg;
        b = bb;
        a = aa;
    }
    HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};

    explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
    {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = 255;
    }

    HPS_INLINE RGBAS32Color (RGB24Color const & c);

    HPS_INLINE RGBAS32Color (RGBA32Color const & c);

    HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
    {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = Float::unit_to_byte(alpha);
    }
    HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
    {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = aa;
    }
    explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
    {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = Float::unit_to_byte(c.alpha);
    }
    HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
    {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = Float::unit_to_byte_scaled(c.alpha, mix);
    }

    HPS_INLINE bool             IsGray() const {return (r == g && g == b);}
    HPS_INLINE unsigned char    Gray() const { return (unsigned char)(0.3125f * (float)r  +  0.5000f * (float)g  +  0.1875f * (float)b); }
    HPS_INLINE bool             IsValid() const { return ((r | g | b | a) != 0); }

    HPS_INLINE bool operator== (RGBAS32Color const & c) const   { return (r == c.r && g == c.g && b == c.b && a == c.a); }
    HPS_INLINE bool operator!= (RGBAS32Color const & c) const   { return !(*this == c); }

    static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
    static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
    static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};

    static  HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
};

class RGBA32Color {
public:
    unsigned char   r;
    unsigned char   g;
    unsigned char   b;
    unsigned char   a;

    HPS_INLINE RGBA32Color () {}
    explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
        : r (gray), g (gray), b (gray), a (aa) {}
    HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
        : r (rr), g (gg), b (bb), a (aa) {}
    HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
        : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
    explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = 255;
    }
    HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = Float::unit_to_byte(alpha);
    }
    HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = aa;
    }
    explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = Float::unit_to_byte(c.alpha);
    }
    HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
        a = Float::unit_to_byte_scaled(c.alpha, mix);
    }

    HPS_INLINE bool             IsGray() const {return (r == g && g == b);}
    HPS_INLINE unsigned char    Gray() const { return (unsigned char)(0.3125f * (float)r  +  0.5000f * (float)g  +  0.1875f * (float)b); }

    HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
    HPS_INLINE bool operator!= (RGBA32Color const & c) const { return  !(*this == c); }

    static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
    static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};

    static  HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
};


class RGB24Color
{
public:
    unsigned char r;
    unsigned char g;
    unsigned char b;

    HPS_INLINE RGB24Color () {}
    explicit HPS_INLINE RGB24Color (unsigned char gray)
        : r (gray), g (gray), b (gray) {}
    HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
        : r (rr), g (gg), b (bb) {}
    explicit HPS_INLINE RGB24Color (RGBColor const & c) {
        r = Float::unit_to_byte(c.red);
        g = Float::unit_to_byte(c.green);
        b = Float::unit_to_byte(c.blue);
    }

    HPS_INLINE bool             IsGray() const {return (r == g && g == b);}
    HPS_INLINE unsigned char    Gray() const { return (unsigned char)(0.3125f * (float)r  +  0.5000f * (float)g  +  0.1875f * (float)b); }

    HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
    HPS_INLINE bool operator!= (RGB24Color const & c) const { return  !(*this == c); }
};

HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
    red = Float::C2F(c32.r);
    green = Float::C2F(c32.g);
    blue = Float::C2F(c32.b);
}

HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
    red = Float::C2F(c32.r);
    green = Float::C2F(c32.g);
    blue = Float::C2F(c32.b);
}

HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
    red = c.red;
    green = c.green;
    blue = c.blue;
}

HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
    red = Float::C2F(c24.r);
    green = Float::C2F(c24.g);
    blue = Float::C2F(c24.b);
}

HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
{
    r = c.r;
    g = c.g;
    b = c.b;
    a = 255;
}

HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
{
    r = c.r;
    g = c.g;
    b = c.b;
    a = c.a;
}

HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
    red = Float::C2F(c32.r);
    green = Float::C2F(c32.g);
    blue = Float::C2F(c32.b);
    alpha = Float::C2F(c32.a);
}

HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
    red = Float::C2F(c32.r);
    green = Float::C2F(c32.g);
    blue = Float::C2F(c32.b);
    alpha = Float::C2F(c32.a);
}

HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
    return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
}



HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
    return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
}

HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
    return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
}

HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
    return RGBAS32Color(
        (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
        (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
        (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
        (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
}

HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
    return RGBA32Color(
        (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
        (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
        (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
        (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
}

HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
    return RGB24Color(
        (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
        (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
        (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
}



class HPS_API Quaternion {
public:
    float       w;
    float       x;
    float       y;
    float       z;

    Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }

    Quaternion(float in_w, float in_x, float in_y, float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }

    Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }

    Quaternion const & Normalize() {
        float mag = Norm();

        if (mag > 0) {
            w /= mag;
            x /= mag;
            y /= mag;
            z /= mag;
        }
        return *this;
    }


    Quaternion operator* (Quaternion const & in_right) const {
        return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
                        y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
                        z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
                        x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
    }

    Quaternion operator* (float in_right) const {
        return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
    }

    friend Quaternion operator* (float in_left, Quaternion const & in_right) {
        return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
    }

    Quaternion operator/ (float in_right) const {
        return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
    }

    Quaternion operator- (Quaternion const & in_right) const {
        return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
    }

    Quaternion operator+ (Quaternion const & in_right) const {
        return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
    }

    inline float Norm() const {
        return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
    }


    Quaternion Log() const {
        Quaternion  ret;
        float       mag_q = Norm();
        float       mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));

        ret.w = static_cast<float>(log(mag_q));

        if (mag_V > 0) {
            float scale = static_cast<float>(acos(w / mag_q) / mag_V);

            ret.x = x * scale;
            ret.y = y * scale;
            ret.z = z * scale;
        }
        else
            ret.x = ret.y = ret.z = 0;

        return ret;
    }

    Quaternion Exp() const {
        Quaternion  ret;
        float       ea = static_cast<float>(exp(w));
        float       mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
        float       scale = ea * sin(mag_V) / mag_V;

        ret.w = ea * cos(mag_V);
        ret.x = scale * x;
        ret.y = scale * y;
        ret.z = scale * z;

        return ret;
    }

    Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
        Quaternion  ret = *this + in_fraction * (in_right - *this);
        return ret.Normalize();
    }


    Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
        Quaternion  q3;
        float       dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;

        if (in_shortest_path_only && dot < 0) {
            dot = -dot;
            q3 = -1 * in_right;
        }
        else
            q3 = in_right;

        if (dot > -0.95f && dot < 0.95f) {
            float    angle = static_cast<float>(acos(dot));
            float    sina = static_cast<float>(sin(angle));
            float    sinat = static_cast<float>(sin(angle*in_fraction));
            float    sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));

            return (*this * sinaomt + q3 * sinat) / sina;
        }
        else //if the angle is small, we use linear interpolation
            return Lerp(q3, in_fraction);
    }


    /*
    Spherical cubic interpolation between two Quaternions
    \param in_right The Quaternion for interpolation.
    \param in_control1 The first control point.
    \param in_control2 The second control point.
    \param in_fraction Interpolation distance (0 - 1).
    \return Result of interpolation.
    */
    Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
        Quaternion  q1 = Slerp(in_right , in_fraction, false);
        Quaternion  q2 = in_control1.Slerp(in_control2, in_fraction, false);

        return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
    }

    Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
        Quaternion qni(w, -x, -y, -z);

        return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
    }

};

struct UpdateInfo
{
    Time update_time;                           
    Time static_time;                           
    size_t dot_dc_count;                        
    size_t dot_3d_count;                        
    size_t line_dc_count;                       
    size_t line_3d_count;                       
    size_t triangle_dc_count;                   
    size_t triangle_3d_count;                   
    size_t polygon_dc_count;                    
    size_t polygon_3d_count;                    
    size_t polyhedron_count;                    
    size_t deleted_display_list_count;          
    size_t display_list_line_3d_count;          
    size_t display_list_triangle_3d_count;      
    size_t display_list_vertex_3d_count;        
    size_t display_list_tristrip_count;         
    size_t non_display_list_tristrip_count;     
    size_t culled_display_list_tristrip_count;  
    size_t raster_count;                        
    size_t segment_count;                       
    size_t frustum_culled_segment_count;        
    size_t extent_culled_segment_count;         
    size_t vector_culled_segment_count;         
    size_t save_region_count;                   
    size_t restore_region_count;                
    size_t statics_created_count;               
    size_t deferred_3d_items_created;           
    size_t deferred_3d_items_deleted;           
    size_t deferred_inplace_items;              
    size_t deferred_sprite_items;               
    size_t deferred_sprite_transparent_items;   
    size_t static_segments;                     
    float static_density;                       
    size_t static_not_drawing;                  
    size_t static_not_flattened_invisible;      
    size_t static_not_flattened_big;            
};

typedef unsigned char   byte;
typedef signed char     sbyte;
typedef intptr_t        WindowHandle;
typedef int64_t         TouchID;
typedef intptr_t        PlatformData;
typedef intptr_t        OpaqueHandle;

/*
HPS Lexicon:

Concept Class -- A class that contains only enums and possibly static functions.  The
        constructor is usually private because they are not intended to be instantiated.

Database -- (1) The internal space that stores and manages all HOOPS objects.  Access to
        database objects is subject to locking to prevent threading deadlocks.  (2) The class
        of the same name, offering static functions to initiate operations that take place
        within the database.

Key -- A reference counted smart pointer to an object in the database.  The

Kit -- A user space object that carries a complete specification for a geometry, attribute,
        option group, or other type.  Modifying a kit has no effect on the database unless
        and until it is applied.  Kits should generally be passed by reference because they
        are potentially very large and copying them can be arduous.

Smart Pointer -- An encapsulated, reference counted pointer to an internal object.  Smart
        pointers should generally be passed by value to ensure the reference count is
        correct.

User Space -- The external space occupied by all user code.  User space objects are not
        in the database and are not subject to locking.

*/

class SegmentKey;
class AttributesControl;
class LineKit;
class LineKey;
class TextKey;
class TextKit;
class Key;
class VisibilityControl;
class CameraControl;
class SelectabilityControl;
class TransparencyKit;
class TransparencyControl;
class CullingKit;
class CullingControl;
class GlyphKit;
class ShapeKit;
class MarkerAttributeControl;
class GlyphDefinition;
class ShapeDefinition;
class GeometryInsertControl;
class GlyphElement;
class ShapeElement;
class TextAttributeControl;
class TextAttributeKit;
class LineAttributeKit;
class LineAttributeControl;
class EdgeAttributeKit;
class EdgeAttributeControl;
class CurveAttributeKit;
class CurveAttributeControl;
class GlyphPoint;
class MatrixKit;
class ModellingMatrixControl;
class TextureMatrixControl;
class TextureDefinition;
class MaterialMappingKit;
class PBRMaterialKit;
class MaterialMappingControl;
class MaterialKit;
class MarkerKit;
class MarkerKey;
class DistantLightKit;
class DistantLightKey;
class CuttingSectionKit;
class CuttingSectionKey;
class CuttingSectionAttributeKit;
class CuttingSectionAttributeControl;
class CylinderAttributeKit;
class CylinderAttributeControl;
class Cylinder;
class CylinderKey;
class CylinderKit;
class SphereKey;
class SphereKit;
class SphereAttributeKit;
class SphereAttributeControl;
class PolygonKit;
class PolygonKey;
class CircleKey;
class CircleKit;
class CircularArcKey;
class CircularArcKit;
class CircularWedgeKey;
class CircularWedgeKit;
class IncludeKey;
class InfiniteLineKey;
class InfiniteLineKit;
class SpotlightKey;
class SpotlightKit;
class NURBSCurveKey;
class NURBSCurveKit;
class NURBSSurfaceKey;
class NURBSSurfaceKit;
class TrimKit;
class TrimElement;
class EllipseKey;
class EllipseKit;
class EllipticalArcKey;
class EllipticalArcKit;
class ShellKit;
class ShellKey;
class Shell;
class MeshKit;
class MeshKey;
class WindowKey;
class Database;
class NURBSSurfaceAttributeKit;
class NURBSSurfaceAttributeControl;
class Driver;
class Search;
class PerformanceKit;
class PerformanceControl;
class HiddenLineAttributeKit;
class HiddenLineAttributeControl;
class DrawingAttributeKit;
class DrawingAttributeControl;
class PortfolioKey;
class Selection;
class SelectionOptionsKit;
class SelectionResults;
class SelectionItem;
class SelectionControl;
class HighlightControl;
class HighlightOptionsKit;
class ImageDefinition;
class ImageKit;
class TextureDefinition;
class TextureOptionsKit;
class NamedStyleDefinition;
class MaterialPaletteDefinition;
class GlyphDefinition;
class LinePatternOptionsKit;
class LinePatternDefinition;
class LinePatternKit;
class LinePatternElement;
class LinePatternParallelKit;
class CubeMapDefinition;
class ShaderKit;
class ShaderDefinition;
class EmergencyHandler;
class EventDispatcher;
class EventHandler;
class Event;
#if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
class StandAloneWindowKey;
class StandAloneWindowOptionsKit;
#endif
class ApplicationWindowKey;
class ApplicationWindowOptionsKit;
class OffScreenWindowKey;
class OffScreenWindowOptionsKit;
class LightingAttributeControl;
class VisualEffectsControl;
class PostProcessEffectsControl;
class SelectionOptionsControl;
class ObjectPoint;
class WorldPoint;
class CameraPoint;
class InnerWindowPoint;
class InnerPixelPoint;
class WindowPoint;
class PixelPoint;
class VisibilityKit;
class CameraKit;
class SelectabilityKit;
class MarkerAttributeKit;
class LightingAttributeKit;
class VisualEffectsKit;
class PostProcessEffectsKit;
class Portfolio;
class SubwindowControl;
class SubwindowKit;
class World;
class DebuggingControl;
class DebuggingKit;
class KeyPath;
class ContourLineKit;
class ContourLineControl;
class UTF8;
class StyleControl;
class PortfolioControl;
class ConditionalExpression;
class ConditionControl;
class WindowInfoKit;
class WindowInfoControl;
class FontInfoState;
class FontInfoControl;
class SearchOptionsKit;
class AttributeLockControl;
class AttributeLockKit;
class ReferenceKey;
class StyleKey;
class BoundingKit;
class BoundingControl;
class TransformMaskKit;
class TransformMaskControl;
class ColorInterpolationKit;
class ColorInterpolationControl;
class UpdateOptionsKit;
class UpdateOptionsControl;
class GeometryKey;
class TreeContext;
class ShellRelationOptionsKit;
class ShellRelationResultsKit;
class GridKit;
class GridKey;
class CutGeometryGatheringOptionsKit;
class SegmentOptimizationOptionsKit;
class HighlightSearchOptionsKit;
class HighlightState;
class HighlightSearchResultsIterator;
class HighlightSearchResults;
class OptimizeMappingResults;
class OptimizeMappingResultsIterator;



class HPS_API GlyphPoint
{
public:

    GlyphPoint();

    GlyphPoint(sbyte in_x, sbyte in_y);

    bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }

    bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }

    bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }

    sbyte x;
    sbyte y;
};

enum class Type : uint32_t
{
    None                                    = 0x00000000,
    GenericMask                             = 0xffffff00,

    World                                   = 0x00000001,
    UTF8                                    = 0x00000002,
    EventDispatcher                         = 0x00000003,
    EventHandler                            = 0x00000004,
    EventNotifier                           = 0x00000005,
    UpdateNotifier                          = 0x00000006,
    SearchResults                           = 0x00000008,
    FontSearchResults                       = 0x00000009,
    SelectionResults                        = 0x0000000a,
    SelectionItem                           = 0x0000000b,
    TreeContext                             = 0x0000000c,
    StreamToolkit                           = 0x0000000d,
    DriverEventHandler                      = 0x0000000e,
    HighlightSearchResults                  = 0x0000000f,
    OptimizeMappingResults                  = 0x00000010,

    IONotifier                              = 0x04000100,
    StreamImportNotifier                    = 0x04000101,
    STLImportNotifier                       = 0x04000102,
    OBJImportNotifier                       = 0x04000103,
    ExchangeImportNotifier                  = 0x04000104,
    SketchupImportNotifier                  = 0x04000105,
    ParasolidImportNotifier                 = 0x04000106,
    ExchangeTranslationNotifier             = 0x04000107,
    ExchangeExportNotifier                  = 0x04000108,
    StreamExportNotifier                    = 0x04000109,
    ExchangeReloadNotifier                  = 0x0400010a,
    DWGImportNotifier                       = 0x0400010b,
    ExchangeParasolidImportNotifier         = 0x0400010c,
    PointCloudImportNotifier                = 0x0400010d,
    OOCImportNotifier                       = 0x0400010e,
    OBJExportNotifier                       = 0x0400010f,
    HCAImportNotifier                       = 0x04000110,

    SearchResultsIterator                   = 0x01000001,
    FontSearchResultsIterator               = 0x01000002,
    SelectionResultsIterator                = 0x01000003,
    HighlightSearchResultsIterator          = 0x01000004,
    OptimizeMappingResultsIterator          = 0x01000005,

    Kit                                     = 0x01000000,
    MarkerKit                               = 0x01000010,
    SphereAttributeKit                      = 0x01000011,
    TextAttributeKit                        = 0x01000012,
    TransparencyKit                         = 0x01000013,
    VisibilityKit                           = 0x01000014,
    VisualEffectsKit                        = 0x01000015,
    CuttingSectionAttributeKit              = 0x01000016,
    CircleKit                               = 0x01000017,
    CircularArcKit                          = 0x01000018,
    CircularWedgeKit                        = 0x01000019,
    CuttingSectionKit                       = 0x0100001a,
    CylinderKit                             = 0x0100001b,
    DistantLightKit                         = 0x0100001c,
    EllipseKit                              = 0x0100001d,
    EllipticalArcKit                        = 0x0100001e,
    InfiniteLineKit                         = 0x0100001f,
    LineKit                                 = 0x01000020,
    NURBSCurveKit                           = 0x01000021,
    MeshKit                                 = 0x01000022,
    NURBSSurfaceKit                         = 0x01000023,
    PolygonKit                              = 0x01000024,
    SphereKit                               = 0x01000025,
    SpotlightKit                            = 0x01000026,
    ShellKit                                = 0x01000027,
    TextKit                                 = 0x01000028,
    MaterialKit                             = 0x01000029,
    TrimKit                                 = 0x0100002a,
    TextureOptionsKit                       = 0x0100002c,
    LinePatternKit                          = 0x0100002d,
    GlyphKit                                = 0x0100002e,
    ImageKit                                = 0x0100002f,
    LinePatternOptionsKit                   = 0x01000030,
    CameraKit                               = 0x01000031,
    BoundingKit                             = 0x01000032,
    CullingKit                              = 0x01000033,
    CurveAttributeKit                       = 0x01000034,
    CylinderAttributeKit                    = 0x01000035,
    EdgeAttributeKit                        = 0x01000036,
    LightingAttributeKit                    = 0x01000037,
    LineAttributeKit                        = 0x01000038,
    MarkerAttributeKit                      = 0x01000039,
    MaterialMappingKit                      = 0x0100003a,
    //MatrixKit                             = 0x0100003b,
    NURBSSurfaceAttributeKit                = 0x0100003c,
    PostProcessEffectsKit                   = 0x0100003d,
    SelectabilityKit                        = 0x0100003e,
    SelectionOptionsKit                     = 0x0100003f,
    StandAloneWindowOptionsKit              = 0x01000040,
    OffScreenWindowOptionsKit               = 0x01000041,
    ApplicationWindowOptionsKit             = 0x01000042,
    HighlightOptionsKit                     = 0x01000043,
    LinePatternParallelKit                  = 0x01000044,
    SubwindowKit                            = 0x01000045,
    PerformanceKit                          = 0x01000046,
    HiddenLineAttributeKit                  = 0x01000047,
    DrawingAttributeKit                     = 0x01000048,
    ShaderKit                               = 0x01000049,
    DebuggingKit                            = 0x0100004a,
    ContourLineKit                          = 0x0100004b,
    StreamImportOptionsKit                  = 0x0100004c,
    StreamImportResultsKit                  = 0x0100004d,
    StreamExportOptionsKit                  = 0x0100004e,
    StreamExportResultsKit                  = 0x0100004f,
    WindowInfoKit                           = 0x01000050,
    ImageImportOptionsKit                   = 0x01000051,
    SearchOptionsKit                        = 0x01000052,
    ShaderImportOptionsKit                  = 0x01000053,
    HardcopyExportOptionsKit                = 0x01000055, // These two use the same Impl, so
    HardcopyGDIExportOptionsKit             = 0x01001055, // we make sure their bits are compatible here
    AttributeLockKit                        = 0x01000056,
    TransformMaskKit                        = 0x01000057,
    ColorInterpolationKit                   = 0x01000058,
    UpdateOptionsKit                        = 0x01000059,
    ImageExportOptionsKit                   = 0x0100005a,
    OBJImportOptionsKit                     = 0x0100005b,
    OBJImportResultsKit                     = 0x0100005c,
    STLImportOptionsKit                     = 0x0100005d,
    STLImportResultsKit                     = 0x0100005e,
    ShellOptimizationOptionsKit             = 0x0100005f,
    ShellRelationOptionsKit                 = 0x01000060,
    ShellRelationResultsKit                 = 0x01000061,
    GridKit                                 = 0x01000062,
    CutGeometryGatheringOptionsKit          = 0x01000063,
    SegmentOptimizationOptionsKit           = 0x01000064,
    PointCloudImportOptionsKit              = 0x01000065,
    PointCloudImportResultsKit              = 0x01000066,
    ShapeKit                                = 0x01000067,
    HighlightSearchOptionsKit               = 0x01000068,
    PBRMaterialKit                          = 0x01000069,

    LinePatternElement                      = 0x03000000,
    SolidLinePatternElement                 = 0x03000001,
    BlankLinePatternElement                 = 0x03000002,
    GlyphLinePatternElement                 = 0x03000003,

    GlyphElement                            = 0x05000000,
    DotGlyphElement                         = 0x05000001,
    LineGlyphElement                        = 0x05000002,
    EllipseGlyphElement                     = 0x05000003,
    CircularArcGlyphElement                 = 0x05000004,
    InfiniteLineGlyphElement                = 0x05000005,
    SphereGlyphElement                      = 0x05000006,
    ImageGlyphElement                       = 0x05000007,

    TrimElement                             = 0x07000000,

    ConditionalExpression                   = 0x09000000,
    NOTCondition                            = 0x09000001,
    ANDCondition                            = 0x09000002,
    ORCondition                             = 0x09000003,
    XORCondition                            = 0x09000004,
    EQCondition                             = 0x09000005,
    NEQCondition                            = 0x09000006,
    GTCondition                             = 0x09000007,
    LTCondition                             = 0x09000008,
    GTEQCondition                           = 0x09000009,
    LTEQCondition                           = 0x0900000A,

    ShapeElement                            = 0x0B000000,
    PolygonShapeElement                     = 0x0B000001,
    EllipseShapeElement                     = 0x0B000002,
    CircleShapeElement                      = 0x0B000003,
    EllipticalArcShapeElement               = 0x0B000004,
    AnchorShapeElement                      = 0x0B000005,
    LineShapeElement                        = 0x0B000006,
    CircularArcShapeElement                 = 0x0B000007,
    LeaderLineClippingElement               = 0x0B000008,

    MouseState                              = 0x01001001,
    TouchState                              = 0x01001002,
    KeyboardState                           = 0x01001003,
    FontInfoState                           = 0x01001004,
    HighlightState                          = 0x01001005,

    KeyPath                                 = 0x01000F01,

    Key                                     = 0x10000000,
    IncludeKey                              = 0x10000001,
    PortfolioKey                            = 0x10000002,
    StyleKey                                = 0x10000003,

    SegmentKey                              = 0x10200000,
    WindowKey                               = 0x10600000,
    StandAloneWindowKey                     = 0x10600001,
    OffScreenWindowKey                      = 0x10600002,
    ApplicationWindowKey                    = 0x10600003,

    GeometryKey                             = 0x10100000,
    ReferenceKey                            = 0x10100001,
    CircleKey                               = 0x10100002,
    CircularArcKey                          = 0x10100003,
    CircularWedgeKey                        = 0x10100004,
    CuttingSectionKey                       = 0x10100005,
    CylinderKey                             = 0x10100006,
    EllipseKey                              = 0x10100007,
    EllipticalArcKey                        = 0x10100008,
    InfiniteLineKey                         = 0x10100009,
    LineKey                                 = 0x1010000a,
    DistantLightKey                         = 0x1010000b,
    SpotlightKey                            = 0x1010000c,
    MarkerKey                               = 0x1010000d,
    MeshKey                                 = 0x1010000e,
    NURBSCurveKey                           = 0x1010000f,
    NURBSSurfaceKey                         = 0x10100010,
    PolygonKey                              = 0x10100011,
    ShellKey                                = 0x10100012,
    SphereKey                               = 0x10100013,
    TextKey                                 = 0x10100014,
    GridKey                                 = 0x10100015,

    Definition                              = 0x20000000,
    NamedStyleDefinition                    = 0x20000001,
    TextureDefinition                       = 0x20000002,
    LinePatternDefinition                   = 0x20000003,
    GlyphDefinition                         = 0x20000004,
    CubeMapDefinition                       = 0x20000005,
    ImageDefinition                         = 0x20000006,
    MaterialPaletteDefinition               = 0x20000007,
    ShaderDefinition                        = 0x20000008,
    ShapeDefinition                         = 0x20000009,

    Control                                 = 0x50000000,
    CameraControl                           = 0x50000001,
    SelectabilityControl                    = 0x50000002,
    MarkerAttributeControl                  = 0x50000003,
    SphereAttributeControl                  = 0x50000004,
    LightingAttributeControl                = 0x50000005,
    CylinderAttributeControl                = 0x50000006,
    TextAttributeControl                    = 0x50000007,
    LineAttributeControl                    = 0x50000008,
    EdgeAttributeControl                    = 0x50000009,
    CurveAttributeControl                   = 0x5000000a,
    ModellingMatrixControl                  = 0x5000000b,
    TextureMatrixControl                    = 0x5000000c,
    CullingControl                          = 0x5000000d,
    TransparencyControl                     = 0x5000000e,
    MaterialMappingControl                  = 0x5000000f,
    NURBSSurfaceAttributeControl            = 0x50000010,
    PostProcessEffectsControl               = 0x50000011,
    BoundingControl                         = 0x50000012,
    VisualEffectsControl                    = 0x50000013,
    SelectionOptionsControl                 = 0x50000014,
    HighlightOptionsControl                 = 0x50000015,
    DefinitionControl                       = 0x50000016,
    SelectionControl                        = 0x50000017,
    HighlightControl                        = 0x50000018,
    StandAloneWindowOptionsControl          = 0x50600019, //Is a Window Key
    OffScreenWindowOptionsControl           = 0x5060001a, //Is a Window Key
    ApplicationWindowOptionsControl         = 0x5060001b, //Is a Window Key
    VisibilityControl                       = 0x5000001c,
    SubwindowControl                        = 0x5000001d,
    PerformanceControl                      = 0x5000001e,
    HiddenLineAttributeControl              = 0x5000001f,
    DrawingAttributeControl                 = 0x50000020,
    DebuggingControl                        = 0x50000021,
    ContourLineControl                      = 0x50000022,
    StyleControl                            = 0x50000023,
    ConditionControl                        = 0x50000024,
    PortfolioControl                        = 0x50000025,
    WindowInfoControl                       = 0x50000026,
    AttributeLockControl                    = 0x50000027,
    TransformMaskControl                    = 0x50000028,
    ColorInterpolationControl               = 0x50000029,
    UpdateOptionsControl                    = 0x50600030, //Is a Window Key
    CuttingSectionAttributeControl          = 0x50000031,

    LibraryMask                             = 0x80FF0000,

    Sprocket                                = 0x80000000,
    Canvas                                  = 0x80000001,
    Layout                                  = 0x80000002,
    View                                    = 0x80000003,
    Model                                   = 0x80000004,
    Operator                                = 0x80000005,
    SprocketPath                            = 0x80000007,

    SprocketControl                         = 0xD0000000,
    OperatorControl                         = 0xD0000008,
    NavigationCubeControl                   = 0xD0000009,
    AxisTriadControl                        = 0xD000000A,

    SprocketKit                             = 0x81000000,

    Metadata                                = 0x80001000,
    IntegerMetadata                         = 0x80001001,
    UnsignedIntegerMetadata                 = 0x80001002,
    DoubleMetadata                          = 0x80001003,
    StringMetadata                          = 0x80001004,
    TimeMetadata                            = 0x80001005,
    BooleanMetadata                         = 0x80001006,

    Component                               = 0x80000200,
    Filter                                  = 0x80000600,
    Capture                                 = 0x80000a00,
    CADModel                                = 0x80000300,
    ComponentPath                           = 0x81001000,

    ExchangeMask                            = 0x80020000,
    ExchangeComponent                       = 0x80021200,
    ExchangeSheet                           = 0x80021201,
    ExchangeProductOccurrence               = 0x80021202,
    ExchangeFilter                          = 0x80020601,
    ExchangeCapture                         = 0x80020a01,
    ExchangeCADModel                        = 0x80020301,
    ExchangeConfiguration                   = 0x81020001,
    ExchangeImportOptionsKit                = 0x81020002,
    ExchangeExportACISOptionsKit            = 0x81020003,
    ExchangeExportIGESOptionsKit            = 0x81020004,
    ExchangeExportJTOptionsKit              = 0x81020005,
    ExchangeExportParasolidOptionsKit       = 0x81020006,
    ExchangeExportPRCOptionsKit             = 0x81020007,
    ExchangeExportSTEPOptionsKit            = 0x81020008,
    ExchangeExportSTLOptionsKit             = 0x81020009,
    ExchangeExportU3DOptionsKit             = 0x8102000a,
    ExchangeExportXMLOptionsKit             = 0x8102000b,
    ExchangeTessellationOptionsKit          = 0x8102000c,
    ExchangeModelFileImportOptionsKit       = 0x8102000d,
    ExchangeTranslationOptionsKit           = 0x8102000e,
    ExchangeNURBSConversionOptionsKit       = 0x8102000f,
    ExchangeExport3MFOptionsKit             = 0x81020010,
    ExchangeExportFBXOptionsKit             = 0x81020011,
    ExchangeExportOBJOptionsKit             = 0x81020012,

    PublishMask                             = 0x80040000,
    PublishDocumentKit                      = 0x81040001,
    PublishPageKit                          = 0x81040002,
    PublishTemplateKit                      = 0x81040003,
    PublishAnnotationKit                    = 0x81040004,
    PublishArtworkKit                       = 0x81040005,
    PublishViewKit                          = 0x81040006,
    PublishTextKit                          = 0x81040007,
    PublishImageKit                         = 0x81040008,
    PublishTableKit                         = 0x81040009,
    PublishExportOptionsKit                 = 0x8104000a,
    PublishLinkKit                          = 0x8104000b,
    PublishButtonKit                        = 0x8104000c,
    PublishTextFieldKit                     = 0x8104000d,
    PublishSlideTableKit                    = 0x8104000e,
    PublishCheckBoxKit                      = 0x8104000f,
    PublishRadioButtonKit                   = 0x81040010,
    PublishListBoxKit                       = 0x81040011,
    PublishDropDownListKit                  = 0x81040012,
    PublishSignatureFieldKit                = 0x81040013,

    PublishDocumentKey                      = 0x80040001,
    PublishPageControl                      = 0x80040002,

    ExchangeParasolidMask                   = 0x80080000,

    SceneTree                               = 0x80008001,
    SceneTreeItem                           = 0x80008002,

    ComponentTree                           = 0x80008003,
    ComponentTreeItem                       = 0x80008004,

    SketchupMask                            = 0x80100000,
    SketchupImportOptionsKit                = 0x81100001,
    SketchupImportResultsKit                = 0x81100002,

    ParasolidMask                           = 0x80200000,
    ParasolidComponent                      = 0x80201201,
    ParasolidCADModel                       = 0x80200302,
    ParasolidImportOptionsKit               = 0x81200003,
    ParasolidFacetTessellationKit           = 0x81200004,
    ParasolidLineTessellationKit            = 0x81200005,
    ParasolidExportOptionsKit               = 0x81200006,

    DWGMask                                 = 0x80400000,
    DWGComponent                            = 0x80401201,
    DWGLayer                                = 0x80401202,
    DWGLayout                               = 0x80400a03,
    DWGCADModel                             = 0x80400304,
    DWGImportOptionsKit                     = 0x81400005,

    OOCMask                                 = 0x80800000,
    OOCImportOptionsKit                     = 0x81800001,
    OOCImportResultsKit                     = 0x81800002,

    HCAMask                                 = 0x80110000,
    HCAImportOptionsKit                     = 0x81110001,
    HCAImportResultsKit                     = 0x81110002,
    HCAModel                                = 0x80110003,
    HCAModelTree                            = 0x80110004,
    HCAModelTreeItem                        = 0x80110005,
    HCANetworkImportOptionsKit              = 0x81110006,

    HTMLMask                                = 0x80010000,


    IONotifierData                          = 0x84000200,
    StreamImportNotifierData                = 0x84000201,
    STLImportNotifierData                   = 0x84000202,
    OBJImportNotifierData                   = 0x84000203,
    ExchangeImportNotifierData              = 0x84020204,
    SketchupImportNotifierData              = 0x84100205,
    ParasolidImportNotifierData             = 0x84200206,
    ExchangeTranslationNotifierData         = 0x84020207,
    ExchangeExportNotifierData              = 0x84020208,
    StreamExportNotifierData                = 0x84000209,
    DWGImportNotifierData                   = 0x8440020a,
    ExchangeParasolidImportNotifierData     = 0x8408020b,
    PointCloudImportNotifierData            = 0x8400020c,
    OOCImportNotifierData                   = 0x8480020d,
    OBJExportNotifierData                   = 0x8400020e,
    HCAImportNotifierData                   = 0x8411020f,

};

class HPS_API Memory
{
public:
    static void *   Allocate(size_t in_bytes, bool in_clear_memory = true);


    static void     Free(void * in_pointer);

private:
    Memory();
};


template <typename T>
class NO_HPS_API Allocator
{
public:
    typedef T                   value_type;
    typedef value_type *        pointer;
    typedef value_type const *  const_pointer;
    typedef value_type &        reference;
    typedef value_type const &  const_reference;
    typedef size_t              size_type;
    typedef ptrdiff_t           difference_type;


    Allocator() {}
    Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
    ~Allocator() {}

    template <typename U> Allocator(Allocator<U> const &) {}

    template <typename U>
    struct rebind
    {
        typedef Allocator<U> other;
    };


    pointer address(reference x) const { return &x; }
    const_pointer address(const_reference x) const { return &x; }

    pointer  allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
    void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }

#if defined(_MSC_VER) || defined (__APPLE__)
    void construct(pointer p, const_reference x) { new(p) T(x); }
    void construct(pointer p, value_type && x) { new(p) T(std::move(x)); }
#else
    template<typename U, typename... Args>
    void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
#endif
    void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }

    size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
};

template <typename T, typename U>
bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }

template <typename T, typename U>
bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }

class Exception : public std::runtime_error
{
public:
    Exception(char const * in_info) : std::runtime_error(in_info) { }
};


class InvalidObjectException : public Exception
{
public:
    InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
      Exception(in_info) {}
};


class IndexOutOfRangeException : public Exception
{
public:
    IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
      Exception(in_info) {}
};


class InvalidSpecificationException : public Exception
{
public:
    InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
      Exception(in_info) {}
};


class InvalidLicenseException : public Exception
{
public:
    InvalidLicenseException(char const * in_info) :
        Exception(in_info) {}
};


class InvalidOperationException : public Exception
{
public:
    InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
        Exception(in_info) {}
};

class IOException : public Exception
{
public:
    IOException(char const * in_info, IOResult in_result)
        : Exception(in_info), result(in_result) {}

    IOResult result;    
};


class HPS_API Object
{
public:

    Object();

    Object(Object const & that);

    virtual ~Object();

    Object & operator=(Object const & other_object);

    Object(Object && in_that);


    Object & operator=(Object && in_that);

    virtual HPS::Type           Type() const;

    static const HPS::Type staticType = HPS::Type::None;

    virtual HPS::Type   ObjectType() const { return staticType; }

    virtual bool Empty() const {return (impl_ == 0);};

    virtual void        Reset();

    bool                HasType(HPS::Type in_mask) const;

    intptr_t            GetClassID() const;

    intptr_t            GetInstanceID() const;

    template <typename T>
    static intptr_t ClassID()
    {
        static const intptr_t ret = T().GetClassID();
        return ret;
    }
private:

    friend class HPSI::Impl;
    friend class HPSI::KeyImpl;
    friend class HPSI::TicketImpl;

    HPSI::Impl * impl_;
};


class HPS_API Control : public Object
{
public:
    virtual HPS::Type Type() const { return ObjectType(); }
    static const HPS::Type staticType = HPS::Type::Control;
    HPS::Type       ObjectType() const { return staticType; }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
    Control(Control const & in_that) = default;
#endif

protected:
    Control() {}

    Control(Control && in_that) : Object(std::move(in_that)) {}

    Control & operator=(Control && in_that)
    {
        this->Object::operator=(std::move(in_that));
        return *this;
    }
};


class HPS_API Kit : public Object
{
public:
    static const HPS::Type staticType = HPS::Type::Kit;
    HPS::Type       ObjectType() const { return staticType; }
    virtual HPS::Type Type() const { return ObjectType(); }

#if !defined(_MSC_VER) || _MSC_VER >= 1900
    Kit(Kit const & in_that) = default;
#endif

protected:
    Kit() {}

    Kit(Kit && in_that) : Object(std::move(in_that)) {}

    Kit & operator=(Kit && in_that)
    {
        this->Object::operator=(std::move(in_that));
        return *this;
    }
};


class HPS_API ObjectPoint : public Point
{
public:

    ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    ObjectPoint(Point const & in_point):Point(in_point){}

    ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);

    ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);

    ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);

    ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:

    ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
    ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
    ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
    ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
    ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
    ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points

};

class HPS_API WorldPoint : public Point
{
public:
    WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    WorldPoint(Point const & in_point):Point(in_point){}

    WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);

    WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);

    WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);

    WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:

    WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
    WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
    WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
    WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
    WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
    WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points

};

class HPS_API CameraPoint : public Point
{
public:
    CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    CameraPoint(Point const & in_point):Point(in_point){}

    CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);

    CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);

    CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);

    CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:
    CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
    CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
    CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
    CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
    CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
    CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points

};

class HPS_API InnerWindowPoint : public Point
{
public:

    InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    InnerWindowPoint(Point const & in_point):Point(in_point){}

    InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);

    InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);

    InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);

    InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:
    InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
    InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
    InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
    InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
    InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
    InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
};

class HPS_API InnerPixelPoint : public Point
{
public:

    InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    InnerPixelPoint(Point const & in_point):Point(in_point){}

    InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);

    InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);

    InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);

    InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:
    InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
    InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
    InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
    InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
    InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
    InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points

};

class HPS_API WindowPoint : public Point
{
public:

    WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    WindowPoint(Point const & in_point):Point(in_point){}

    WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);

    WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);

    WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);

    WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:
    WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
    WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
    WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
    WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
    WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
    WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
};


class HPS_API PixelPoint : public Point
{
public:
    PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}

    PixelPoint(Point const & in_point):Point(in_point){}

    PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);

    PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);

    PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);

    PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);

    PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);

    PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);

    PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);

private:
    PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
    PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
    PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
    PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
    PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
    PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points

};

class HPS_API Event
{
public:
    enum class Status : uint32_t
    {
        InProgress,         
        Completed,          
        Failed              
    };

    Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}

    virtual ~Event();

    intptr_t            GetClassID() const;

    virtual Event *     Clone() const=0;

    virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }

    virtual intptr_t    Freshen() const { return 0; }

    intptr_t            GetChannel() const { return channel; }

    Time                GetTimeStamp() const { return time_stamp; }

    bool IsConsumable() const { return consumable; }

    static void *       operator new (size_t in_size) { return Memory::Allocate(in_size); }
    static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }

protected:
    intptr_t    channel;
    bool        consumable;

private:
    friend class HPSI::EventDispatcherImpl;
    Time        time_stamp;
};


class HPS_API EventNotifier : public Object
{
public:

    EventNotifier();

    EventNotifier(EventNotifier const & in_that);

    EventNotifier(EventNotifier && in_that);

    EventNotifier & operator=(EventNotifier && in_that);

    virtual ~EventNotifier();

    static const HPS::Type staticType = HPS::Type::EventNotifier;
    HPS::Type               ObjectType() const {return staticType;};

    EventNotifier &         operator=(EventNotifier const & in_that);

    virtual void            Assign(EventNotifier const & in_that);

    EventNotifier const &   Wait() const;

    Event::Status           Status() const;
};

enum class KeyboardCode : uint32_t
{
    None                = 0,    

    Backspace           = 8,    
    Tab                 = 9,    
    Clear               = 11,   
    Return              = 13,   
    Shift               = 16,   
    Control             = 17,   
    Alt                 = 18,   
    Pause               = 19,   
    Escape              = 27,   

    Space               = 32,   
    ExclamationMark,            
    DoubleQuote,
    Number,
    Dollar,
    Percent,
    Ampersand,
    SingleQuote,
    OpenParen,
    CloseParen,

    Asterisk,                   
    Plus,                       
    Comma,                      
    Hyphen,                     
    Period,                     
    Slash,                      

    D0,                         
    D1,                         
    D2,                         
    D3,                         
    D4,                         
    D5,                         
    D6,                         
    D7,                         
    D8,                         
    D9,                         

    Colon,                      
    Semicolon,                  
    LessThan,
    Equal,                      
    GreaterThan,
    QuestionMark,
    AtSymbol,

    A,                          
    B,                          
    C,                          
    D,                          
    E,                          
    F,                          
    G,                          
    H,                          
    I,                          
    J,                          
    K,                          
    L,                          
    M,                          
    N,                          
    O,                          
    P,                          
    Q,                          
    R,                          
    S,                          
    T,                          
    U,                          
    V,                          
    W,                          
    X,                          
    Y,                          
    Z,                          

    OpenBrackets,
    Backslash,
    CloseBrackets,
    Caret,
    Underscore,
    Backtick,

    a,                          
    b,                          
    c,                          
    d,                          
    e,                          
    f,                          
    g,                          
    h,                          
    i,                          
    j,                          
    k,                          
    l,                          
    m,                          
    n,                          
    o,                          
    p,                          
    q,                          
    r,                          
    s,                          
    t,                          
    u,                          
    v,                          
    w,                          
    x,                          
    y,                          
    z,                          

    OpenBrace,
    VerticalBar,
    ClosingBrace,
    Tilde,
    Delete,                     

    Insert=1024,                
    Home,                       
    End,                        
    PageUp,                     
    PageDown,                   

    Help,                       

    Left,                       
    Up,                         
    Right,                      
    Down,                       

    NumPad0,                    
    NumPad1,                    
    NumPad2,                    
    NumPad3,                    
    NumPad4,                    
    NumPad5,                    
    NumPad6,                    
    NumPad7,                    
    NumPad8,                    
    NumPad9,                    

    F1,                         
    F2,                         
    F3,                         
    F4,                         
    F5,                         
    F6,                         
    F7,                         
    F8,                         
    F9,                         
    F10,                        
    F11,                        
    F12,                        
    F13,                        
    F14,                        
    F15,                        
    F16,                        
    F17,                        
    F18,                        
    F19,                        
    F20,                        
    F21,                        
    F22,                        
    F23,                        
    F24,                        

    CapsLock,                   
    NumLock,                    
    ScrollLock,                 
    LeftShift,                  
    RightShift,                 
    LeftCtrl,                   
    RightCtrl,                  
    LeftAlt,                    
    RightAlt,                   

    Select,                     
    Print,                      
    Execute,                    
    PrintScreen,                
};


class NO_HPS_API Touch
{
public:

    Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}

    Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
        : ID(in_id), Location(in_location), TapCount(in_tap_count) {}

    inline bool operator==(Touch const & in_that) const
 {
        return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
    }

    inline bool operator!=(Touch const & in_that) const
 {
        return !(*this == in_that);
    }

    TouchID     ID;             
    WindowPoint Location;       
    size_t TapCount;       
};
typedef std::vector<Point, Allocator<Point> >                                                                 PointArray;                                     
typedef std::vector<ObjectPoint, Allocator<ObjectPoint> >                                                 ObjectPointArray;                     
typedef std::vector<WorldPoint, Allocator<WorldPoint> >                                                   WorldPointArray;                  
typedef std::vector<CameraPoint, Allocator<CameraPoint> >                                                 CameraPointArray;                 
typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> >                           InnerWindowPointArray;            
typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> >                                 InnerPixelPointArray;             
typedef std::vector<WindowPoint, Allocator<WindowPoint> >                                                 WindowPointArray;                 
typedef std::vector<PixelPoint, Allocator<PixelPoint> >                                                   PixelPointArray;                  
typedef std::vector<Vector, Allocator<Vector> >                                                               VectorArray;                      
typedef std::vector<DVector, Allocator<DVector> >                                                             DVectorArray;                     
typedef std::vector<Plane, Allocator<Plane> >                                                                   PlaneArray;                       
typedef std::vector<int, Allocator<int> >                                                                         IntArray;                         
typedef std::vector<RGBColor, Allocator<RGBColor> >                                                         RGBColorArray;                    
typedef std::vector<RGBAColor, Allocator<RGBAColor> >                                                       RGBAColorArray;                   
typedef std::vector<unsigned int, Allocator<unsigned int> >                                           UnsignedIntArray;                 
typedef std::vector<size_t, Allocator<size_t> >                                                               SizeTArray;                       
typedef std::vector<float, Allocator<float> >                                                                   FloatArray;                       
typedef std::vector<SegmentKey, Allocator<SegmentKey> >                                                 SegmentKeyArray;                  
typedef std::vector<WindowKey, Allocator<WindowKey> >                                                       WindowKeyArray;                   
typedef std::vector<EventHandler, Allocator<EventHandler> >                                           EventHandlerArray;                
typedef std::vector<GlyphElement, Allocator<GlyphElement> >                                           GlyphElementArray;                
typedef std::vector<ShapeElement, Allocator<ShapeElement> >                                           ShapeElementArray;                
typedef std::vector<GlyphPoint, Allocator<GlyphPoint> >                                                   GlyphPointArray;                  
typedef std::vector<UTF8, Allocator<UTF8> >                                                                     UTF8Array;                        
typedef std::vector<UTF8Array, Allocator<UTF8Array> >                                                       UTF8ArrayArray;                   
typedef std::vector<bool, Allocator<bool> >                                                                     BoolArray;                        
typedef std::vector<TrimKit, Allocator<TrimKit> >                                                             TrimKitArray;                     
typedef std::vector<Key, Allocator<Key> >                                                                         KeyArray;                         
typedef std::vector<PortfolioKey, Allocator<PortfolioKey> >                                           PortfolioKeyArray;                
typedef std::vector<char, Allocator<char> >                                                                     CharArray;                        
typedef std::vector<wchar_t, Allocator<wchar_t> >                                                             WCharArray;                       
typedef std::vector<byte, Allocator<byte> >                                                                     ByteArray;                        
typedef std::vector<ByteArray, Allocator<ByteArray> >                                                       ByteArrayArray;                   
typedef std::vector<sbyte, Allocator<sbyte> >                                                                   SByteArray;                       
typedef std::vector<MaterialKit, Allocator<MaterialKit> >                                                 MaterialKitArray;                 
typedef std::vector<LinePatternElement, Allocator<LinePatternElement> >                           LinePatternElementArray;          
typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> >             LinePatternParallelKitArray;      
typedef std::vector<Material::Type, Allocator<Material::Type> >                                       MaterialTypeArray;                
typedef std::vector<Search::Type, Allocator<Search::Type> >                                             SearchTypeArray;                  
typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> >                                     LineSizeUnitsArray;               
typedef std::vector<CameraKit, Allocator<CameraKit> >                                                       CameraKitArray;                   
typedef std::vector<ConditionalExpression, Allocator<ConditionalExpression> >                   ConditionalExpressionArray;       
typedef std::vector<TextureDefinition, Allocator<TextureDefinition> >                               TextureDefinitionArray;           
typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> >                               CubeMapDefinitionArray;           
typedef std::vector<ImageDefinition, Allocator<ImageDefinition> >                                     ImageDefinitionArray;             
typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> >                     NamedStyleDefinitionArray;        
typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> >       MaterialPaletteDefinitionArray;   
typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> >                                     GlyphDefinitionArray;             
typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> >                   LinePatternDefinitionArray;       
typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> >                                 ShaderDefinitionArray;            
typedef std::vector<ShapeDefinition, Allocator<ShapeDefinition> >                                     ShapeDefinitionArray;             
typedef std::vector<IntRectangle, Allocator<IntRectangle> >                                             IntRectangleArray;                
typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> >                         AttributeLockTypeArray;           
typedef std::vector<Style::Type, Allocator<Style::Type> >                                                 StyleTypeArray;                   
typedef std::vector<TrimElement, Allocator<TrimElement> >                                                 TrimElementArray;                 
typedef std::vector<KeyPath, Allocator<KeyPath> >                                                             KeyPathArray;                     
typedef std::vector<IncludeKey, Allocator<IncludeKey> >                                                   IncludeKeyArray;                  
typedef std::vector<KeyboardCode, Allocator<KeyboardCode> >                                           KeyboardCodeArray;                
typedef std::vector<Touch, Allocator<Touch> >                                                                   TouchArray;                       
typedef std::vector<ReferenceKey, Allocator<ReferenceKey> >                                           ReferenceKeyArray;                
typedef std::vector<intptr_t, Allocator<intptr_t> >                                                         IntPtrTArray;                     
typedef std::vector<GeometryKey, Allocator<GeometryKey> >                                                 GeometryKeyArray;                 
typedef std::vector<Shell::Relation, Allocator<Shell::Relation> >                                 ShellRelationArray;               
typedef std::vector<StyleKey, Allocator<StyleKey> >                                                         StyleKeyArray;                    
typedef std::vector<PointArray, Allocator<PointArray> >                                                   PointArrayArray;                  
typedef std::vector<Text::MarginUnits, Allocator<Text::MarginUnits> >                         TextMarginUnitsArray;             
typedef std::vector<PointArrayArray, Allocator<PointArrayArray> >                                 PointArrayArrayArray;             
typedef std::vector<Drawing::ClipSpace, Allocator<Drawing::ClipSpace> >                   ClipSpaceArray;                   
typedef std::vector<Drawing::ClipOperation, Allocator<Drawing::ClipOperation> >               ClipOperationArray;               
typedef std::vector<MatrixKit, Allocator<MatrixKit> >                                                       MatrixKitArray;                   
typedef std::vector<int32_t, Allocator<int32_t>>                                                        Int32Array;                       
typedef std::vector<int64_t, HPS::Allocator<int64_t>>                                                   Int64Array;                       
typedef std::vector<Line::CoordinateSpace, Allocator<Line::CoordinateSpace>>                            LineCoordinateSpaceArray;                   
typedef std::vector<Drawing::Overlay, Allocator<Drawing::Overlay>>                                              DrawingOverlayArray;                            
typedef std::vector<HighlightState, Allocator<HighlightState>>                                                      HighlightStateArray;                            
typedef std::vector<ImageKit, Allocator<ImageKit>>                                          ImageKitArray; 

class HPS_API ShapeCoordinate
{
public:
    ShapeCoordinate();

    ShapeCoordinate(float in_x, float in_y);

    ShapeCoordinate(float in_x, float in_y, FloatArray const & in_margins);

    ShapeCoordinate(float in_x, float in_y, size_t in_count, float const in_margins []);

    ShapeCoordinate(float in_x, float in_y, float in_radius);

    ShapeCoordinate(float in_x, float in_y, float in_radius, FloatArray const & in_margins);

    ShapeCoordinate(float in_x, float in_y, float in_radius, size_t in_count, float const in_margins []);

    bool Equals(ShapeCoordinate const & in_that) const;

    bool operator==(ShapeCoordinate const & in_that) const { return Equals(in_that); }

    bool operator!=(ShapeCoordinate const & in_that) const { return !Equals(in_that); }

    ShapeCoordinate & SetMargins(float in_margin_one, float in_margin_two = 0.0f, float in_margin_three = 0.0f, float in_margin_four = 0.0f);

    bool ShowMargins(FloatArray & out_margins) const;

    ShapeCoordinate & UnsetMargins();

    float x;
    float y;
    float radius;
    FloatArray margins;
};

class HPS_API ShapePoint
{
public:
    ShapePoint();

    ShapePoint(ShapeCoordinate const & in_x, ShapeCoordinate const & in_y);

    ShapePoint(float in_x, float in_y);

    bool Equals(ShapePoint const & in_that) const { return (x == in_that.x && y == in_that.y); }

    bool operator==(ShapePoint const & in_that) const { return Equals(in_that); }

    bool operator!=(ShapePoint const & in_that) const { return !Equals(in_that); }

    ShapeCoordinate x;
    ShapeCoordinate y;
};

typedef std::vector<ShapePoint, Allocator<ShapePoint> >                                 ShapePointArray;

class HPS_API SearchResultsIterator : public Object
{
public:

    SearchResultsIterator();

    SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);

    SearchResultsIterator(SearchResultsIterator && in_that);

    SearchResultsIterator & operator=(SearchResultsIterator && in_that);

    ~SearchResultsIterator();

    static const HPS::Type staticType = HPS::Type::SearchResultsIterator;
    HPS::Type                           ObjectType() const {return staticType;}

    SearchResultsIterator &             operator=(SearchResultsIterator const & in_search_results_iterator);

    void                                Set(SearchResultsIterator const & in_search_results_iterator);

    void                                Next();

    SearchResultsIterator &             operator++();

    SearchResultsIterator               operator++(int in_val);

    bool                                operator==(SearchResultsIterator const & in_search_results_iterator);

    bool                                operator!=(SearchResultsIterator const & in_search_results_iterator);

    bool                                IsValid() const;

    void                                Reset();

    Key                                 GetItem() const;

    Key                                 operator*() const;

    SearchTypeArray                     GetResultTypes() const;
};

class HPS_API SearchResults : public Object
{
public:
    SearchResults();

    SearchResults(SearchResults const & in_search_results);

    SearchResults(SearchResults && in_that);

    SearchResults & operator=(SearchResults && in_that);

    virtual void                Reset();

    ~SearchResults();

    static const HPS::Type staticType = HPS::Type::SearchResults;
    HPS::Type               ObjectType() const {return staticType;}

    void                    Assign(SearchResults const & in_search_results);

    SearchResults &         operator=(SearchResults const & in_search_results);

    size_t                  GetCount() const;

    SearchResultsIterator   GetIterator() const;
};

class HPS_API FontSearchResultsIterator : public Object
{
public:

    FontSearchResultsIterator();

    FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);

    FontSearchResultsIterator(FontSearchResultsIterator && in_that);

    FontSearchResultsIterator &                 operator=(FontSearchResultsIterator const & in_search_results_iterator);


    FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);

    ~FontSearchResultsIterator();

    static const HPS::Type staticType = HPS::Type::FontSearchResultsIterator;
    HPS::Type                                   ObjectType() const {return staticType;}


    void                                        Set(FontSearchResultsIterator const & in_search_results_iterator);

    void                                        Next();

    FontSearchResultsIterator &                 operator++();

    FontSearchResultsIterator                   operator++(int in_val);

    bool                                        operator==(FontSearchResultsIterator const & in_search_results_iterator);

    bool                                        operator!=(FontSearchResultsIterator const & in_search_results_iterator);

    bool                                        IsValid() const;

    void                                        Reset();

    FontInfoState                               GetItem() const;

    FontInfoState                               operator*() const;

};

class HPS_API FontSearchResults : public Object
{
public:

    FontSearchResults();

    FontSearchResults(FontSearchResults const & in_search_results);

    FontSearchResults(FontSearchResults && in_that);

    FontSearchResults & operator=(FontSearchResults && in_that);

    virtual void                Reset();

    ~FontSearchResults();

    static const HPS::Type staticType = HPS::Type::FontSearchResults;
    HPS::Type                       ObjectType() const {return staticType;}

    void                            Assign(FontSearchResults const & in_search_results);


    FontSearchResults &             operator=(FontSearchResults const & in_search_results);

    size_t                          GetCount() const;

    FontSearchResultsIterator       GetIterator() const;
};

class HPS_API UTF8
{
public:

    UTF8();

    ~UTF8();

    UTF8(char const * in_string, char const * in_locale = 0);

    UTF8(wchar_t const * in_string);

    UTF8(UTF8 const & in_that);

    UTF8(UTF8 && in_that);

    UTF8 & Assign(UTF8 && in_utf8);

    inline UTF8 & operator= (UTF8 && in_utf8)
    {
        return Assign(std::move(in_utf8));
    }

    size_t ToWStr(wchar_t * out_wide_string) const;

    size_t ToWStr(WCharArray & out_wide_string) const;

    inline bool IsValid() const
 {
        return (_length > 0);
    }

    inline bool Empty() const
 {
        return (_length == 0);
    }

    void Clear();

    void Reset() { Clear(); }

    inline size_t GetLength() const
 {
        return _length;
    }

    inline size_t GetWStrLength() const
 {
        return ToWStr(0);
    }

    inline char const * GetBytes() const
 {
        return _text;
    }

    inline operator char const * () const
    {
        return _text;
    }

    char At(size_t in_index) const
 {
        if(!IsValid())
            throw InvalidObjectException();
        else if(in_index >= _length)
            throw IndexOutOfRangeException();
        else
            return _text[in_index];
    }

    UTF8 & Assign(UTF8 const & in_utf8);

    inline UTF8 & operator= (UTF8 const & in_utf8)
    {
        return Assign(in_utf8);
    }

    UTF8 & operator+= (UTF8 const & in_utf8);

    UTF8 & operator+= (char const * in_utf8);

    UTF8 operator+ (UTF8 const & in_utf8) const;

    UTF8 operator+ (char const * in_utf8) const;

    bool operator== (UTF8 const & in_utf8) const;

    bool operator!= (UTF8 const & in_utf8) const
 {
        return !(*this == in_utf8);
    }

    bool operator== (char const * in_utf8) const;

    bool operator!= (char const * in_utf8) const
 {
        return !(*this == in_utf8);
    }

    friend inline bool operator==(char const * in_left, UTF8 const & in_right)
    {
        return in_right == in_left;
    }

    friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
    {
        return in_right != in_left;
    }

    friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
    {
        return in_right == UTF8(in_left);
    }

    friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
    {
        return in_right != UTF8(in_left);
    }

    friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
    {
        return UTF8(in_left, "utf8") + in_right;
    }

    friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
    {
        return UTF8(in_left) + in_right;
    }


    size_t GetHash() const;

    friend class HPSI::String;

private:

    size_t internal_encode(wchar_t const * in_wide_string);
    static size_t internal_decode(size_t in_length, const char* in_utf8_string, wchar_t * out_wide_string);
    size_t internal_decode(wchar_t * out_wide_string) const;

    char *              _text;
    size_t              _length;
    mutable size_t      _hash_key;
    static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
    char                _buffer[_buffer_size];
};

struct UTF8Hasher {
    inline size_t operator()(const HPS::UTF8 & in_utf8) const
 {
        return in_utf8.GetHash();
    }
};

class HPS_API ConditionalExpression : public Object
{
public:

    ConditionalExpression();

    ConditionalExpression(char const * in_condition);

    ConditionalExpression(float in_number);

    ConditionalExpression(HPS::Condition::Intrinsic in_special);

    ConditionalExpression(ConditionalExpression const & in_that);

    ConditionalExpression(ConditionalExpression && in_that);

    ConditionalExpression & operator=(ConditionalExpression && in_that);

    static const HPS::Type staticType = HPS::Type::ConditionalExpression;
    HPS::Type           ObjectType() const { return staticType; }

    bool                ShowCondition(UTF8 & out_condition) const;

    bool                ShowNumber(float & out_number) const;

    bool                ShowIntrinsic(Condition::Intrinsic & out_special) const;

    bool                ShowOperands(ConditionalExpressionArray & out_operands) const;

    ConditionalExpression &         operator=(ConditionalExpression const & in_that);

    bool                Equals(ConditionalExpression const & in_that) const;

    bool                operator==(ConditionalExpression const & in_that) const;

    bool                operator!=(ConditionalExpression const & in_that) const;

    bool                IsSatisfiedBy(UTF8Array const & in_conditions) const;

    bool                IsSatisfiedBy(char const * in_condition) const;

    ConditionalExpression   OR(ConditionalExpression const & in_operand2) const;

    ConditionalExpression   XOR(ConditionalExpression const & in_operand2) const;

    ConditionalExpression   AND(ConditionalExpression const & in_operand2) const;

    ConditionalExpression   EQ(ConditionalExpression const & in_operand2)