hps.h
1 
2 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
3 //
4 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
5 // and considered a trade secret as defined under civil and criminal statutes.
6 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
7 // unauthorized use or misappropriation of its trade secrets. Use of this information
8 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
9 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
10 
11 #ifndef HPS_H
12 #define HPS_H
13 
14 #ifdef _MSC_VER
15 # ifndef STATIC_APP
16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
19 # else
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
22 # endif
23 # define HPS_TEMPLATE_API __declspec (dllexport)
24 # endif
25 # ifdef _WINDOWS_
26 # undef Ellipse
27 # undef Polyline
28 # undef Polygon
29 # undef Rectangle
30 # undef min
31 # undef max
32 # endif
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
35 #else
36 # include <limits.h>
37 # include <stddef.h>
38 # ifdef LINUX_SYSTEM
39 # ifndef STATIC_APP
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
43 # else
44 # define EXPIMP_TEMPLATE extern
45 # endif
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
47 # endif
48 # endif
49 #endif
50 #ifndef HPS_API
51 # define HPS_API
52 #endif
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
55 #endif
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
58 #endif
59 #ifndef ENUM_CLASS
60 # define ENUM_CLASS enum class
61 #endif
62 
63 #define NO_HPS_API
64 
65 #include <stdint.h>
66 #include <memory>
67 #include <vector>
68 #include <math.h>
69 #include <float.h>
70 #include <limits>
71 #include <stdexcept>
72 #include <algorithm>
73 #include <cstring>
74 
75 
76 
77 namespace HPSI
78 {
79  class Impl;
80  class KeyImpl;
81  class TicketImpl;
82  class EventDispatcherImpl;
83  class AbstractImage;
84 };
85 
86 namespace HPS
87 {
88 
89  // unimplemented
90 
91 
92 //Begin Info
94 class HPS_API Info
95 {
96 public:
99  enum class Code {
100  Unknown,
101  Exchange,
102  Publish,
103  Data,
104  Key,
105  Geometry,
106  Database,
107  Driver,
108  Internal,
109  Memory,
110  System,
111  Unsupported,
112  };
113 
114 private:
116  Info();
117 };
118 
119 
120 //Begin Info
122 class HPS_API Emergency
123 {
124 public:
127  enum class Code {
128  Unknown,
129  Fatal,
130  SoftMemoryLimit,
131  HardMemoryLimit,
132  };
133 
134 private:
136  Emergency();
137 };
138 
139 
140 //Begin Window
142 class HPS_API Window
143 {
144 public:
147  enum class Driver {
148  Default3D,
149  OpenGL,
150  OpenGL2,
151  DirectX9,
152  DirectX11,
153  };
154 
157  enum class UpdateStatus {
158  InProgress,
159  Completed,
160  TimedOut,
161  Interrupted,
162  Failed
163  };
164 
168  enum class UpdateControl {
169  DefaultUpdate,
170 
173  CompleteUpdate,
174 
175  RefreshUpdate,
176 
177  CompileOnlyUpdate,
178 
182  ExhaustiveUpdate,
183  };
184 
187  enum class Mobility
188  {
189  Locked,
190  Floating,
191  FixedRatio,
192  Free
193  };
194 
198  enum class FrameSize
199  {
200  Single,
201  Double
202  };
203 
207  enum class FrameOptions
208  {
209  Inset,
210  Overlay
211  };
212 
213  enum class ImageFormat
214  {
215  Default,
216  RGBA,
217  RGB,
218  Jpeg,
219  Png
220  };
221 
222 private:
224  Window();
225 };
226 
227 //Begin Subwindow
229 class HPS_API Subwindow
230 {
231 public:
232  enum class Background
233  {
234  SolidColor,
235  Image,
236  Cubemap,
237  Blend,
238  Transparent,
239  Interactive,
240 
241  GradientTopToBottom,
242  GradientBottomToTop,
243  GradientLeftToRight,
244  GradientRightToLeft,
245  GradientTopLeftToBottomRight,
246  GradientTopRightToBottomLeft,
247  GradientBottomLeftToTopRight,
248  GradientBottomRightToTopLeft,
249  };
250 
251  enum class Type
252  {
253  Standard,
254  Lightweight
255  };
256 
257  enum class Border
258  {
259  None,
260  Inset,
261  InsetBold,
262  Overlay,
263  OverlayBold
264  };
265 
266 
269  {
272  ZBuffer,
273 
279  HiddenLine,
280 
286  FastHiddenLine,
287 
300  Priority
301  };
302 
303 private:
304  Subwindow();
305 };
306 //End Subwindow
307 
309 class HPS_API Style
310 {
311 public:
312 
316  enum class Type
317  {
318  Segment,
319  Named
320  };
321 
325  enum class AppendMode
326  {
327  None,
328  And,
329  Or
330  };
331 
332 private:
333  Style();
334 };
335 
336 
337 //Begin Shell Attributes
339 class HPS_API Shell
340 {
341 public:
342 
345  enum class Component
346  {
347  Faces,
348  Edges,
349  Vertices
350  };
351 
352  /* \enum ToleranceUnits
353  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
354  enum class ToleranceUnits
355  {
356  ObjectSpace,
357  FeatureSizePercentage
358  };
359 
360  /* \enum HandednessOptimization
361  * Enumerates the shell optimization options with regards to handedness. */
363  {
364  None,
365  FixHandedness,
366  ReverseHandedness
367  };
368 
369  /* \enum RelationResults
370  * Enumerates the results of a shell relation computation. */
371  enum class Relation
372  {
373  On,
374  Off,
375  In,
376  Out
377  };
378 
379  /* \enum RelationTest
380  * Enumerates the test options for a shell relation computation. */
381  enum class RelationTest
382  {
383  Simple,
384  Enclosure,
385  Distance
386  };
387 
388 private:
390  Shell();
391 };
392 //End Shell Attributes
393 
394 //Begin Mesh Attributes
396 class HPS_API Mesh
397 {
398 public:
401  enum class Component
402  {
403  Faces,
404  Edges,
405  Vertices
406  };
407 
408 private:
410  Mesh();
411 };
412 //End Mesh Attributes
413 
414 //Begin InfiniteLine Attributes
416 class HPS_API InfiniteLine
417 {
418 public:
421  enum class Type
422  {
423  Line,
424  Ray
425  };
426 
427 private:
429  InfiniteLine();
430 };
431 //End InfiniteLine Attributes
432 
434 class HPS_API Trim
435 {
436 public:
439  enum class Type
440  {
441  Line,
442  Curve
443  };
444 
448  enum class Operation
449  {
450  Keep,
451  Remove
452  };
453 private:
455  Trim();
456 };
457 
458 //Begin Spotlight Attributes
460 class HPS_API Spotlight
461 {
462 public:
465  enum class OuterConeUnits
466  {
470  Degrees,
474  FieldRadius
475  };
476 
479  enum class InnerConeUnits
480  {
484  Degrees,
488  FieldRadius,
491  Percent
492  };
493 
494 
495 private:
497  Spotlight();
498 };
499 //End Spotlight Attributes
500 
501 
502 
503 
504 //Begin Cylinder Attributes
506 class HPS_API Cylinder
507 {
508 public:
511  enum class Component
512  {
513  Faces,
514  Edges,
515  };
516 
519  enum class Capping
520  {
521  None,
522  First,
523  Last,
524  Both
525  };
526 
530  enum class Orientation
531  {
532  Default,
533  DefaultRadii,
534  InvertRadii,
535  InvertRadiiOnly,
536  DefaultColors,
537  InvertColors,
538  InvertColorsOnly,
539  InvertAll
540  };
541 
542 private:
544  Cylinder();
545 };
546 
547 
549 class HPS_API Search
550 {
551 public:
554  enum class Space
555  {
556  SegmentOnly,
557  Subsegments,
558  SubsegmentsAndIncludes
559  };
560 
563  enum class Behavior
564  {
565  Exhaustive,
566  FirstMatch
567  };
568 
569 
570  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to 3DF HK types (if they map to HK types)
574  enum class Type : uint32_t {
575 
576  /* This enum classeration is divided into three parts.
577 
578  0xAABBBCCC
579 
580  The bits in A encode the most general category of the type (Geometry, Attribute).
581  The bits in B encode the subtype (Culling, TextAttribute). Attributes alone have these so far.
582  The bits in C encode the specific type (Shell, CullingVectorTolerance, TextAttributeSpacing).
583 
584  General category designators should have no bits in B or C.
585  Subtype category designators should have bits in A and B but not C.
586  Specific category designators should have bits in A and C and optionally B.
587 
588  Some types map to an HK type. To get the HK type you should mask out its subtype if it has one, else mask out its general type.
589  These types are kept in sync with the 3DF HK types by using Compile-time assets in hpsi.cpp.
590 
591  Geometry have no subtype. Most, 'Ordinary Geometry' map to a 3DF HK type.
592  The mutants or 'Special Geometry' (some lights and infinite ray) have no HK type to map to.
593 
594  Attributes come in a few forms.
595  The 'Simple Attributes' map to an HK type and have no subtypes -- they are what they are. ModellingMatrix, Camera, etc.
596  The 'Complex Attributes' have subtypes. A handful map to an HK type, but the majority are not.
597  */
598  None = 0x00000000,
599  Everything = 0x00ffffff,
600 
601  // Segment Stuff (Include & Segment map to HK types)
602  Include = 0x00000042,
603  Segment = 0x00000043,
604 
605  Includer = 0x00000100,
606 
607  // Geometry
608  Geometry = 0x10000000,
609 
610  // Ordinary Geometry (map to HK types) - (HK_* | Geometry)
611  CuttingSection = 0x10000026,
612  Shell = 0x10000028,
613  Mesh = 0x10000029,
614  Grid = 0x1000002a,
615  NURBSSurface = 0x1000002b,
616  Cylinder = 0x1000002d,
617  Sphere = 0x1000002e,
618  Polygon = 0x1000002f,
619  Circle = 0x10000030,
620  //unused = 0x10000031,
621  CircularWedge = 0x10000032,
622  Ellipse = 0x10000033,
623  Line = 0x10000034,
624  NURBSCurve = 0x10000037,
625  CircularArc = 0x10000038,
626  EllipticalArc = 0x10000039,
627  InfiniteLine = 0x1000003a,
628 // Image = 0x1000003b, N/A since images live in portfolios
629  Marker = 0x1000003c,
630  Text = 0x1000003e,
631  Reference = 0x10000040,
632 
633  // Special Geometry
634  DistantLight = 0x10000100,
635  Spotlight = 0x10000101,
636  InfiniteRay = 0x10000102,
637 
638  // Attributes
639  Attribute = 0x20000000,
640 
641  Priority = 0x20000001,
642 
643  // Simple Attributes (map to HK types)
644  Material = 0x2000000a,
645  Camera = 0x2000000e,
646  ModellingMatrix = 0x20000010,
647  UserData = 0x20000021,
648  TextureMatrix = 0x20000023,
649 
650  // Complex Attributes
651  Culling = 0x20001000,
652  CullingBackFace = 0x20001001,
653  CullingExtent = 0x20001002,
654  CullingVector = 0x20001003,
655  CullingVectorTolerance = 0x20001004,
656  CullingFrustum = 0x20001005,
657  CullingDeferralExtent = 0x20001006,
658 
659  CurveAttribute = 0x20002000,
660  CurveAttributeBudget = 0x20002001,
661  CurveAttributeContinuedBudget = 0x20002002,
662  CurveAttributeViewDependent = 0x20002003,
663  CurveAttributeMaximumDeviation = 0x20002004,
664  CurveAttributeMaximumAngle = 0x20002005,
665  CurveAttributeMaximumLength = 0x20002006,
666 
667  CylinderAttribute = 0x20003000,
668  CylinderAttributeTessellation = 0x20003001,
669  CylinderAttributeOrientation = 0x20003002,
670 
671  // EdgeAttributes map to HK types
672  EdgeAttribute = 0x20004000,
673  EdgeAttributePattern = 0x20004015,
674  EdgeAttributeWeight = 0x20004016,
675 
676  LightingAttribute = 0x20005000,
677  LightingAttributeInterpolation = 0x20005001,
678 
679  // LineAttributes map to HK types
680  LineAttribute = 0x20006000,
681  LineAttributePattern = 0x20006019,
682  LineAttributeWeight = 0x2000601a,
683 
684  // MarkerAttributes map to HK types
685  MarkerAttribute = 0x20007000,
686  MarkerAttributeSize = 0x2000701b,
687  MarkerAttributeSymbol = 0x2000701c,
688 
689  SurfaceAttribute = 0x20008000,
690  SurfaceAttributeBudget = 0x20008001,
691  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
692  SurfaceAttributeMaximumFacetAngle = 0x20008003,
693  SurfaceAttributeMaximumFacetWidth = 0x20008004,
694  SurfaceAttributeTrimCurveBudget = 0x20008005,
695  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
696 
697  Selectability = 0x20009000,
698  SelectabilityWindows = 0x20009001,
699  SelectabilityEdges = 0x20009002,
700  SelectabilityFaces = 0x20009003,
701  SelectabilityLights = 0x20009004,
702  SelectabilityLines = 0x20009005,
703  SelectabilityMarkers = 0x20009006,
704  SelectabilityVertices = 0x20009007,
705  SelectabilityText = 0x20009008,
706 
707  SphereAttribute = 0x2000a000,
708  SphereAttributeTessellation = 0x2000a001,
709 
710  Subwindow = 0x2000b000,
711  SubwindowEitherType = 0x2000b001,
712  SubwindowStandard = 0x2000b00d,
713  SubwindowLightweight = 0x2000b002,
714  SubwindowBackground = 0x2000b003,
715  SubwindowBorder = 0x2000b004,
716  SubwindowRenderingAlgorithm = 0x2000b005,
717 
718  // TextAttributeAlignment, Path, & Spacing map to HK types
719  TextAttribute = 0x2000c000,
720  TextAttributeAlignment = 0x2000c01d,
721  TextAttributeBold = 0x2000c002,
722  TextAttributeItalic = 0x2000c003,
723  TextAttributeOverline = 0x2000c004,
724  TextAttributeStrikethrough = 0x2000c005,
725  TextAttributeUnderline = 0x2000c006,
726  TextAttributeSlant = 0x2000c007,
727  TextAttributeLineSpacing = 0x2000c008,
728  TextAttributeRotation = 0x2000c00a,
729  TextAttributeExtraSpace = 0x2000c00b,
730  TextAttributeGreeking = 0x2000c00c,
731  TextAttributeSizeTolerance = 0x2000c00d,
732  TextAttributeSize = 0x2000c00e,
733  TextAttributeFont = 0x2000c00f,
734  TextAttributeTransform = 0x2000c010,
735  TextAttributeRenderer = 0x2000c011,
736  TextAttributePreference = 0x2000c012,
737  TextAttributePath = 0x2000c01f,
738  TextAttributeSpacing = 0x2000c020,
739 
740  Transparency = 0x2000d000,
741  TransparencyMethod = 0x2000d001,
742  TransparencyAlgorithm = 0x2000d002,
743  TransparencyDepthPeelingLayers = 0x2000d004,
744  TransparencyDepthPeelingMinimumArea = 0x2000d005,
745  TransparencyDepthWriting = 0x2000d006,
746 
747  Visibility = 0x2000e000,
748  VisibilityCuttingSections = 0x2000e001,
749  VisibilityCutEdges = 0x2000e002,
750  VisibilityCutFaces = 0x2000e003,
751  VisibilityWindows = 0x2000e004,
752  VisibilityText = 0x2000e005,
753  VisibilityLines = 0x2000e006,
754  VisibilityEdgeLights = 0x2000e007,
755  VisibilityMarkerLights = 0x2000e008,
756  VisibilityFaceLights = 0x2000e009,
757  VisibilityGenericEdges = 0x2000e00a,
758  VisibilityHardEdges = 0x2000e00b,
759  VisibilityAdjacentEdges = 0x2000e00c,
760  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
761  VisibilityShadowEmitting = 0x2000e00e,
762  VisibilityShadowReceiving = 0x2000e00f,
763  VisibilityShadowCasting = 0x2000e010,
764  VisibilityMarkers = 0x2000e011,
765  VisibilityVertices = 0x2000e012,
766  VisibilityFaces = 0x2000e013,
767  VisibilityPerimeterEdges = 0x2000e014,
768  VisibilityNonCulledEdges = 0x2000e015,
769  VisibilityMeshQuadEdges = 0x2000e016,
770 
771  VisualEffects = 0x2000f000,
772  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
773  VisualEffectsAntiAliasing = 0x2000f002,
774  VisualEffectsShadowMaps = 0x2000f003,
775  VisualEffectsSimpleShadow = 0x2000f004,
776  VisualEffectsSimpleShadowPlane = 0x2000f005,
777  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
778  VisualEffectsSimpleShadowColor = 0x2000f007,
779  VisualEffectsSimpleReflection = 0x2000f008,
780  VisualEffectsSimpleReflectionPlane = 0x2000f009,
781  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
782 
783  Performance = 0x20010000,
784  PerformanceDisplayLists = 0x20010001,
785  PerformanceStaticModel = 0x20010002,
786  StaticModelSegment = 0x40000043,
787 
788  // DrawingAttributeWorldHandedness map to HK types
789  DrawingAttribute = 0x20011000,
790  DrawingAttributePolygonHandedness = 0x20011001,
791  DrawingAttributeDepthRange = 0x20011002,
792  DrawingAttributeFaceDisplacement = 0x20011003,
793  DrawingAttributeGeneralDisplacement = 0x20011004,
794  DrawingAttributeVertexDisplacement = 0x20011005,
795  DrawingAttributeOverlay = 0x20011006,
796  DrawingAttributeDeferral = 0x20011007,
797  DrawingAttributeClipRegion = 0x20011012,
798  DrawingAttributeWorldHandedness = 0x20011018,
799 
800  HiddenLineAttribute = 0x20012000,
801  HiddenLineAttributeColor = 0x20012001,
802  HiddenLineAttributeDimFactor = 0x20012002,
803  HiddenLineAttributeFaceDisplacement = 0x20012003,
804  HiddenLineAttributeLinePattern = 0x20012005,
805  HiddenLineAttributeRenderFaces = 0x20012006,
806  HiddenLineAttributeRenderText = 0x20012007,
807  HiddenLineAttributeAlgorithm = 0x20012008,
808  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
809  HiddenLineAttributeVisibility = 0x2001200a,
810  HiddenLineAttributeWeight = 0x2001200b,
811  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
812 
813  SegmentStyle = 0x20013001,
814  NamedStyle = 0x20013002,
815  MaterialPalette = 0x20013003,
816  Portfolio = 0x20013004,
817 
818  ContourLine = 0x20014000,
819  ContourLineVisibility = 0x20014001,
820  ContourLinePosition = 0x20014002,
821  ContourLineColor = 0x20014003,
822  ContourLinePattern = 0x20014004,
823  ContourLineWeight = 0x20014005,
824  ContourLineLighting = 0x20014006,
825 
826  Condition = 0x20015000,
827 
828  Bounding = 0x20016000,
829  BoundingVolume = 0x20016001,
830  BoundingExclusion = 0x20016002,
831 
832  AttributeLock = 0x20017000,
833  AttributeLockSetting = 0x20017001,
834  AttributeLockSubsegmentOverride = 0x20017002,
835 
836  TransformMask = 0x20018000,
837  TransformMaskCamera = 0x20018001,
838  TransformMaskCameraTranslation = 0x20018002,
839  TransformMaskCameraScale = 0x20018003,
840  TransformMaskCameraOffset = 0x20018004,
841  TransformMaskCameraRotation = 0x20018005,
842  TransformMaskCameraPerspectiveScale = 0x20018006,
843  TransformMaskCameraProjection = 0x20018007,
844  TransformMaskModellingMatrix = 0x20018008,
845  TransformMaskModellingMatrixTranslation = 0x20018009,
846  TransformMaskModellingMatrixScale = 0x20018010,
847  TransformMaskModellingMatrixOffset = 0x20018011,
848  TransformMaskModellingMatrixRotation = 0x20018012,
849 
850  ColorInterpolation = 0x20019000,
851  ColorInterpolationFaceColor = 0x20019001,
852  ColorInterpolationEdgeColor = 0x20019002,
853  ColorInterpolationMarkerColor = 0x20019003,
854  ColorInterpolationFaceIndex = 0x20019004,
855  ColorInterpolationEdgeIndex = 0x20019005,
856  ColorInterpolationMarkerIndex = 0x20019006,
857 
858  CuttingSectionAttribute = 0x2001a000,
859  CuttingSectionAttributeCuttingLevel = 0x2001a001,
860  CuttingSectionAttributeCappingLevel = 0x2001a002,
861  CuttingSectionAttributeMaterialPreference = 0x2001a003,
862 
863  };
864  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to HK types (if they are map to HK types)
865 
866 private:
868  Search();
869 };
870 
872 class HPS_API Material
873 {
874 public:
877  enum class Type
878  {
879  InvalidMaterialIndex = -1,
880  Nothing = 0,
881  FullMaterial,
882  ExplicitRGBColor,
883  ExplicitRGBAColor,
884  MaterialIndex,
885  TextureName,
886  ModulatedTexture,
887  CubeMapName,
888  ModulatedCubeMap,
889  GlossValue,
890  DiffuseChannelAlpha
891 
892  };
893 
897  enum class Channel
898  {
899  DiffuseColor = 1,
900  DiffuseTexture = 2,
901  Specular = 3,
902  Emission = 4,
903  Transmission = 5,
904  Mirror = 6,
905  Bump = 7,
906  EnvironmentTexture = 8,
907  EnvironmentCubeMap = 9,
908  Gloss = 10
909  };
910 
912  class HPS_API Color
913  {
914  public:
918  enum class Channel
919  {
920  DiffuseColor = 1,
921  Specular = 3,
922  Emission = 4,
923  Mirror = 6
924  };
925 
926  private:
928  Color();
929  };
930 
932  class HPS_API Texture
933  {
934  public:
938  enum class Channel
939  {
940  DiffuseTexture = 2,
941  Specular = 3,
942  Emission = 4,
943  Transmission = 5,
944  Mirror = 6,
945  Bump = 7,
946  EnvironmentTexture = 8,
947  EnvironmentCubeMap = 9
948  };
949 
952  enum class Parameterization
953  {
955  Cylinder,
957  PhysicalReflection,
959  Object,
965  NaturalUV,
967  ReflectionVector,
969  SurfaceNormal,
971  Sphere,
973  UV,
975  World
976  };
977 
980  enum class Tiling
981  {
984  Clamp,
986  Repeat,
988  Reflect,
991  Trim
992  };
993 
996  enum class Interpolation
997  {
999  Bilinear,
1000 
1002  InterpolationOff
1003  };
1004 
1007  enum class Decimation
1008  {
1011  Anisotropic,
1013  Mipmap,
1015  DecimationOff
1016  };
1017 
1021  enum class ChannelMapping
1022  {
1023  Red,
1024  Green,
1025  Blue,
1026  Alpha,
1027  Zero,
1028  One,
1029  Luminance
1030  };
1031 
1032  private:
1034  Texture();
1035  };
1036 private:
1038  Material();
1039 };
1040 
1041 class HPS_API PostProcessEffects
1042 {
1043 public:
1044  class HPS_API AmbientOcclusion
1045  {
1046  public:
1050  enum class Quality
1051  {
1052  Fastest,
1053  Nicest
1054  };
1055 
1056  private:
1057  AmbientOcclusion();
1058  };
1059 
1060  class HPS_API Bloom
1061  {
1062  public:
1066  enum class Shape
1067  {
1068  Star,
1069  Radial
1070  };
1071 
1072  private:
1073  Bloom();
1074  };
1075 
1076 private:
1077  PostProcessEffects() {}
1078 };
1079 
1080 class HPS_API Performance
1081 {
1082 public:
1086  enum class DisplayLists
1087  {
1089  NoDisplayLists,
1090 
1093  GeometryDisplayLists,
1094 
1097  SegmentDisplayLists
1098  };
1099 
1108  enum class StaticModel
1109  {
1110 
1111  NoStaticModel,
1112  AttributeStaticModel,
1113  AttributeSpatialStaticModel
1114  };
1115 
1116 
1117 private:
1118  Performance() {}
1119 };
1120 
1121 
1122 class HPS_API AttributeLock
1123 {
1124 public:
1125 
1127  enum class Type : uint32_t
1128  {
1129  Everything = 0x01000000,
1130 
1131  Visibility = 0x02000000,
1132 
1133  VisibilityCuttingSections,
1134  VisibilityCutEdges,
1135  VisibilityCutFaces,
1136  VisibilityWindows,
1137  VisibilityText,
1138  VisibilityLines,
1139  VisibilityEdgeLights,
1140  VisibilityMarkerLights,
1141  VisibilityFaceLights,
1142  VisibilityGenericEdges,
1143  VisibilityHardEdges,
1144  VisibilityAdjacentEdges,
1145  VisibilityInteriorSilhouetteEdges,
1146  VisibilityShadowEmitting,
1147  VisibilityShadowReceiving,
1148  VisibilityShadowCasting,
1149  VisibilityMarkers,
1150  VisibilityVertices,
1151  VisibilityFaces,
1152  VisibilityPerimeterEdges,
1153  VisibilityNonCulledEdges,
1154  VisibilityMeshQuadEdges,
1155  VisibilityCutGeometry,
1156  VisibilityEdges,
1157  VisibilityGeometry,
1158  VisibilityLights,
1159  VisibilityShadows,
1160 
1161  Material = 0x03000000,
1162 
1163  MaterialGeometry,
1164  MaterialCutGeometry,
1165 
1166  MaterialAmbientLightUpColor,
1167  MaterialAmbientLightDownColor,
1168  MaterialAmbientLightColor,
1169 
1170  MaterialWindowColor,
1171  MaterialWindowContrastColor,
1172 
1173  MaterialLightColor,
1174  MaterialLineColor,
1175  MaterialMarkerColor,
1176  MaterialTextColor,
1177  MaterialCutEdgeColor,
1178 
1179  MaterialVertex,
1180  MaterialVertexDiffuse,
1181  MaterialVertexDiffuseColor,
1182  MaterialVertexDiffuseAlpha,
1183  MaterialVertexDiffuseTexture,
1184  MaterialVertexSpecular,
1185  MaterialVertexMirror,
1186  MaterialVertexTransmission,
1187  MaterialVertexEmission,
1188  MaterialVertexEnvironment,
1189  MaterialVertexBump,
1190  MaterialVertexGloss,
1191 
1192  MaterialEdge,
1193  MaterialEdgeDiffuse,
1194  MaterialEdgeDiffuseColor,
1195  MaterialEdgeDiffuseAlpha,
1196  MaterialEdgeDiffuseTexture,
1197  MaterialEdgeSpecular,
1198  MaterialEdgeMirror,
1199  MaterialEdgeTransmission,
1200  MaterialEdgeEmission,
1201  MaterialEdgeEnvironment,
1202  MaterialEdgeBump,
1203  MaterialEdgeGloss,
1204 
1205  MaterialFace,
1206  MaterialFaceDiffuse,
1207  MaterialFaceDiffuseColor,
1208  MaterialFaceDiffuseAlpha,
1209  MaterialFaceDiffuseTexture,
1210  MaterialFaceSpecular,
1211  MaterialFaceMirror,
1212  MaterialFaceTransmission,
1213  MaterialFaceEmission,
1214  MaterialFaceEnvironment,
1215  MaterialFaceBump,
1216  MaterialFaceGloss,
1217 
1218  MaterialBackFace,
1219  MaterialBackFaceDiffuse,
1220  MaterialBackFaceDiffuseColor,
1221  MaterialBackFaceDiffuseAlpha,
1222  MaterialBackFaceDiffuseTexture,
1223  MaterialBackFaceSpecular,
1224  MaterialBackFaceMirror,
1225  MaterialBackFaceTransmission,
1226  MaterialBackFaceEmission,
1227  MaterialBackFaceEnvironment,
1228  MaterialBackFaceBump,
1229  MaterialBackFaceGloss,
1230 
1231  MaterialFrontFace,
1232  MaterialFrontFaceDiffuse,
1233  MaterialFrontFaceDiffuseColor,
1234  MaterialFrontFaceDiffuseAlpha,
1235  MaterialFrontFaceDiffuseTexture,
1236  MaterialFrontFaceSpecular,
1237  MaterialFrontFaceMirror,
1238  MaterialFrontFaceTransmission,
1239  MaterialFrontFaceEmission,
1240  MaterialFrontFaceEnvironment,
1241  MaterialFrontFaceBump,
1242  MaterialFrontFaceGloss,
1243 
1244  MaterialCutFace,
1245  MaterialCutFaceDiffuse,
1246  MaterialCutFaceDiffuseColor,
1247  MaterialCutFaceDiffuseAlpha,
1248  MaterialCutFaceDiffuseTexture,
1249  MaterialCutFaceSpecular,
1250  MaterialCutFaceMirror,
1251  MaterialCutFaceTransmission,
1252  MaterialCutFaceEmission,
1253  MaterialCutFaceEnvironment,
1254  MaterialCutFaceBump,
1255  MaterialCutFaceGloss,
1256 
1257  Camera = 0x04000000,
1258  };
1259 
1260 private:
1261  AttributeLock() {}
1262 };
1263 
1264 class HPS_API Drawing
1265 {
1266 public:
1269  enum class Handedness
1270  {
1271  NoHandedness,
1272  Left,
1273  Right
1274  };
1275 
1278  enum class Overlay
1279  {
1281  NoOverlay,
1284  NormalOverlay,
1287  OverlayWithZValues,
1288 
1293  InPlace,
1294  };
1295 
1298  enum class ClipOperation
1299  {
1300  Keep,
1301  Remove,
1302  };
1303 
1306  enum class ClipSpace
1307  {
1308  Window,
1309  World,
1310  Object,
1311  };
1312 
1313 private:
1314  Drawing() {}
1315 };
1316 
1317 
1318 class HPS_API HiddenLine
1319 {
1320 public:
1324  enum class Algorithm
1325  {
1326  None,
1327  ZBuffer,
1328  ZSort,
1329  };
1330 
1331 private:
1332  HiddenLine() {}
1333 };
1334 
1335 
1337 class HPS_API Selection
1338 {
1339 public:
1342  enum class Level
1343  {
1344  Segment,
1345  Entity,
1346  Subentity,
1347  };
1348 
1351  enum class Algorithm
1352  {
1353  Visual,
1354  Analytic
1355  };
1356 
1359  enum class Granularity
1360  {
1361  General,
1362  Detailed
1363  };
1364 
1365 private:
1367  Selection();
1368 };
1369 
1370 
1374 
1375 //Begin Camera
1377 class HPS_API Camera
1378 {
1379 public:
1388  enum class Projection {
1389  Default=1,
1390  Perspective,
1391  Orthographic,
1392  Stretched,
1393  };
1396 private:
1397  Camera();
1398 };
1399 
1400 
1401 //Begin Selectability
1403 class HPS_API Selectability
1404 {
1405 public:
1409  enum class Value
1410  {
1411  Off=0,
1412  On,
1413  ForcedOn
1414  };
1415 
1416 private:
1417  Selectability();
1418 };
1419 
1420 // Begin Transparency
1422 class HPS_API Transparency
1423 {
1424 public:
1428  enum class Method
1429  {
1430  Off,
1431  Blended,
1432  ScreenDoor
1433  };
1434 
1438  enum class Algorithm
1439  {
1440  NoSorting,
1441  Painters,
1442  ZSortNicest,
1443  ZSortFastest,
1444  DepthPeeling
1445  };
1446 
1450  enum class AreaUnits
1451  {
1452  Percent,
1453  Pixels
1454  };
1455 
1456 private:
1457  Transparency() {}
1458 };
1459 
1460 
1461 
1462 //Begin Marker Attributes
1464 class HPS_API Marker
1465 {
1466 public:
1470  enum class SizeUnits
1471  {
1472  ScaleFactor,
1473  ObjectSpace,
1474  SubscreenRelative,
1475  WindowRelative,
1476  WorldSpace,
1477  Points,
1478  Pixels
1479 
1480  };
1481 private:
1482  Marker();
1483 };
1484 
1485 //Begin Sphere Attributes
1487 class HPS_API Sphere
1488 {
1489 public:
1490 
1491 private:
1492  Sphere();
1493 };
1494 
1495 
1496 //Begin Lighting Attributes
1498 class HPS_API Lighting
1499 {
1500 public:
1505  {
1506  Phong,
1507  Gouraud,
1508  Flat
1509  };
1510 
1511 private:
1512  Lighting();
1513 };
1514 
1516 class HPS_API Text
1517 {
1518 public:
1521  enum class Alignment
1522  {
1523  TopLeft,
1524  CenterLeft,
1525  BottomLeft,
1526  TopCenter,
1527  Center,
1528  BottomCenter,
1529  TopRight,
1530  CenterRight,
1531  BottomRight
1532  };
1533 
1536  enum class ReferenceFrame
1537  {
1538  WorldAligned,
1539  PathAligned
1540  };
1541 
1544  enum class Justification
1545  {
1546  LeftJustified,
1547  RightJustified,
1548  CenterJustified
1549  };
1550 
1553  enum class Transform
1554  {
1556  Transformable,
1559  NonTransformable,
1561  CharacterPositionOnly,
1564  CharacterPositionAdjusted
1565  };
1566 
1569  enum class Renderer
1570  {
1571  DefaultRenderer,
1572  DriverRenderer,
1573  TruetypeRenderer,
1574  };
1575 
1578  enum class Preference
1579  {
1580  Default,
1581  Vector,
1582  Raster,
1583  Exterior
1584  };
1585 
1588  enum class Rotation
1589  {
1590  NoRotation,
1591  Rotate,
1592  FollowPath
1593  };
1594 
1595 
1598  enum class SizeUnits
1599  {
1600  ObjectSpace,
1601  SubscreenRelative,
1602  WindowRelative,
1603  WorldSpace,
1604  Points,
1605  Pixels
1606  };
1607 
1611  {
1612  ObjectSpace,
1613  SubscreenRelative,
1614  WindowRelative,
1615  WorldSpace,
1616  Points,
1617  Pixels,
1618  Percent
1619  };
1620 
1623  enum class GreekingUnits
1624  {
1625  ObjectSpace,
1626  SubscreenRelative,
1627  WindowRelative,
1628  WorldSpace,
1629  Points,
1630  Pixels
1631  };
1632 
1635  enum class GreekingMode
1636  {
1637  Nothing,
1638  Lines,
1639  Box
1640  };
1641 
1644  enum class RegionAlignment
1645  {
1646  RegionTop,
1647  RegionCenter,
1648  RegionBottom
1649  };
1650 
1651 private:
1653  Text();
1654 };
1655 
1656 // Begin Line Attributes
1657 
1659 class HPS_API Line
1660 {
1661 public:
1665  enum class SizeUnits
1666  {
1667  ScaleFactor,
1668  ObjectSpace,
1669  SubscreenRelative,
1670  WindowRelative,
1671  WorldSpace,
1672  Points,
1673  Pixels
1674  };
1675 private:
1676  Line();
1677 };
1678 
1679 
1680 // Begin Edge Attributes
1681 
1683 class HPS_API Edge
1684 {
1685 public:
1689  enum class SizeUnits
1690  {
1691  ScaleFactor,
1692  ObjectSpace,
1693  SubscreenRelative,
1694  WindowRelative,
1695  WorldSpace,
1696  Points,
1697  Pixels
1698  };
1699 private:
1700  Edge();
1701 };
1702 
1703 
1705 class HPS_API CuttingSection
1706 {
1707 public:
1710  enum class Mode
1711  {
1712  None,
1713  Round,
1714  Square,
1715  Plane
1716  };
1717 
1720  enum class CappingLevel
1721  {
1722  Entity,
1723  Segment,
1724  SegmentTree
1725  };
1726 
1729  enum class CuttingLevel
1730  {
1731  Global,
1732  Local,
1733  };
1734 
1738  {
1739  Explicit,
1740  Implicit,
1741  };
1742 
1745  enum class GatheringLevel
1746  {
1747  Segment,
1748  SegmentTree
1749  };
1750 
1751 private:
1753  CuttingSection();
1754 };
1755 
1757 class HPS_API ContourLine
1758 {
1759 public:
1763  enum class Mode
1764  {
1765  Repeating,
1766  Explicit,
1767  };
1768 
1769 private:
1770  ContourLine();
1771 };
1772 
1775 enum class IOResult
1776 {
1777  Success,
1778  Failure,
1779  FileNotFound,
1780  UnableToOpenFile,
1781  InvalidOptions,
1782  InvalidSegment,
1783  InProgress,
1784  Canceled,
1785  UnableToLoadLibraries,
1786  VersionIncompatibility,
1787  InitializationFailed,
1788  UnsupportedFormat,
1789 };
1790 
1792 class HPS_API LinePattern
1793 {
1794 public:
1797  enum class SizeUnits
1798  {
1799  ObjectSpace,
1800  SubscreenRelative,
1801  WindowRelative,
1802  WorldSpace,
1803  Points,
1804  Pixels,
1805  ScaleFactor
1806  };
1807 
1810  enum class InsetBehavior
1811  {
1812  Overlap,
1813  Trim,
1814  Inline
1815  };
1816 
1820  enum class Join
1821  {
1822  MitreJoin,
1823  RoundJoin,
1824  BevelJoin
1825  };
1826 
1829  enum class Cap
1830  {
1833  ButtCap,
1836  SquareCap,
1839  RoundCap,
1841  MitreCap
1842  };
1843 
1846  enum class Justification
1847  {
1850  Center,
1852  Stretch
1853  };
1854 
1857  enum class Modifier
1858  {
1859  GlyphName,
1860  Enumerated
1861  };
1862 
1863 
1878  enum class Default
1879  {
1880  Solid,
1881  DashDot,
1882  Dashed,
1883  Dotted,
1884  Dash2Dot,
1885  Dash3Dot,
1886  LongDash,
1887  LongDashShortDash,
1888  LongDash2ShortDash,
1889  FineDot,
1890  };
1891 
1892 private:
1894  LinePattern();
1895 };
1896 
1897 
1898 //Begin Glyphs
1900 class HPS_API Glyph
1901 {
1902 public:
1905  enum class Fill
1906  {
1907  Unfilled,
1908  ContinuousFill,
1909  NewFill
1910  };
1911 
1914  enum class ColorSource
1915  {
1916  Normal,
1917  Explicit,
1918  Indexed
1919  };
1920 
1924  enum class Default
1925  {
1926  Circle,
1927  CircleWithDot,
1928  CircleWithPlus,
1929  CircleWithTimes,
1930  CircleWithCircle,
1931  SolidCircle,
1932  Dot,
1933  Plus,
1934  Times,
1935  Splat,
1936  Box,
1937  BoxWithDot,
1938  BoxWithTimes,
1939  SolidBox,
1940  Diamond,
1941  DiamondWithDot,
1942  DiamondWithPlus,
1943  SolidDiamond,
1944  TriangleUp,
1945  TriangleUpWithDot,
1946  SolidTriangleUp,
1947  TriangleDown,
1948  TriangleDownWithDot,
1949  SolidTriangleDown,
1950  TriangleRight,
1951  TriangleRightWithDot,
1952  SolidTriangleRight,
1953  TriangleLeft,
1954  TriangleLeftWithDot,
1955  SolidTriangleLeft,
1956  TriangleUpV,
1957  SolidTriangleUpV,
1958  TriangleDownV,
1959  SolidTriangleDownV,
1960  TriangleRightV,
1961  SolidTriangleRightV,
1962  TriangleLeftV,
1963  SolidTriangleLeftV,
1964  LetterY,
1965  LetterZ,
1966  CircleLetterY,
1967  CircleLetterZ,
1968  VerticalBar,
1969  HorizontalBar,
1970  SlantLeft,
1971  SlantRight,
1972  WidePlus,
1973  SolidWidePlus,
1974  WideTimes,
1975  SolidWideTimes,
1976  Pound,
1977  };
1978 
1979 private:
1981  Glyph();
1982 };
1983 
1984 
1986 class HPS_API Bounding
1987 {
1988 public:
1992  enum class Type
1993  {
1994  None,
1995  Sphere,
1996  Cuboid
1997  };
1998 
1999 private:
2000  Bounding() {}
2001 };
2002 
2004 class HPS_API Grid
2005 {
2006 public:
2009  enum class Type
2010  {
2011  Quadrilateral,
2012  Radial
2013  };
2014 
2015 private:
2016  Grid();
2017 };
2018 
2019 
2021 {
2022 public:
2023  enum class UserData
2024  {
2025  Nothing,
2026  Discard,
2027  Preserve,
2028  Merge,
2029  Localize,
2030  };
2031 
2032  enum class Scope
2033  {
2034  SubSegments,
2035  SubsegmentsAndIncludes,
2036  };
2037 
2038  enum class Expansion
2039  {
2040  None,
2041  Includes,
2042  References,
2043  IncludesAndReferences,
2044  };
2045 
2046  enum class Matrix
2047  {
2048  Nothing,
2049  Localize,
2050  Collapse,
2051  };
2052 
2053  enum class Reorganization
2054  {
2055  None,
2056  Attribute,
2057  Spatial,
2058  AttributeSpatial,
2059  };
2060 };
2061 
2062  typedef double Time;
2063 
2064 #ifdef _MSC_VER
2065 # ifndef HPS_INLINE
2066 # define HPS_INLINE __forceinline
2067 # endif
2068 #else
2069 # define HPS_INLINE inline
2070 #endif
2071 
2072 #ifndef HPS_UNREFERENCED
2073 #define HPS_UNREFERENCED(param) ((void)(param))
2074 #endif
2075 
2076 
2077 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2078 
2079 template<typename T>
2080 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2081 {
2082  return degrees * (T)(PI / 180.0);
2083 }
2084 
2085 template<typename T>
2086 HPS_INLINE T Radians_To_Degrees(T const & radians)
2087 {
2088  return radians * (T)(180.0 / PI);
2089 }
2090 
2091 template<typename T>
2092 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2093  T a = Degrees_To_Radians(angle);
2094  cosine = cos(a);
2095  sine = sin(a);
2096 }
2097 
2098 template<typename T>
2099 HPS_INLINE T Cos(T const & angle) {
2100  return cos (Degrees_To_Radians(angle));
2101 }
2102 
2103 template<typename T>
2104 HPS_INLINE T Sin(T const & angle) {
2105  return sin (Degrees_To_Radians(angle));
2106 }
2107 
2108 template<typename T>
2109 HPS_INLINE T ACos(T const & x) {
2110  if (x > 1)
2111  return 0;
2112  if (x < -1)
2113  return 180;
2114  return Radians_To_Degrees(acos(x));
2115 }
2116 
2117 template<typename T>
2118 HPS_INLINE T ATan2(T const & y, T const & x) {
2119  if (x == 0 && y == 0)
2120  return 0;
2121  return Radians_To_Degrees(atan2(y, x));
2122 }
2123 
2124 
2125 template <typename F> struct Float_Traits {};
2126 template <> struct Float_Traits<float> {
2127  typedef double Alternative;
2128  static const int Type = 1;
2129  static float Epsilon () { return 1.0e-30f; }
2130 };
2131 template <> struct Float_Traits<double> {
2132  typedef float Alternative;
2133  static const int Type = 2;
2134  static double Epsilon () { return 1.0e-300; }
2135 };
2136 
2137 
2138 
2140 class HPS_API Float {
2141 private:
2142  enum Parts {
2143 # if HOOPS_BIGENDIAN
2144  High, Low
2145 # else
2146  Low, High
2147 # endif
2148  };
2149 
2150  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2151  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2152  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2153  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2154  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2155 
2156  static HPS_INLINE bool is_nan(int32_t const & v) {
2157  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2158  return exp == 0x7F800000 && mantissa != 0;
2159  }
2160  static HPS_INLINE bool is_nan(uint32_t const & v) {
2161  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2162  return exp == 0x7F800000 && mantissa != 0;
2163  }
2164  static HPS_INLINE bool is_nan(int32_t const * v) {
2165  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2166  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2167  }
2168  static HPS_INLINE bool is_nan(uint32_t const * v) {
2169  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2170  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2171  }
2172 
2173  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2174  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2175  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2176  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2177 public:
2178 
2180  static const float Infinity;
2182  static const float NegativeInfinity;
2183 
2185  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2186  static HPS_INLINE bool IsInfinite(double const & a) {
2187  uint32_t v[2];
2188  memcpy (v, &a, sizeof(double));
2189  return is_infinite (v);
2190  }
2191 
2193  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2194  static HPS_INLINE bool IsNAN(double const & a) {
2195  uint32_t v[2];
2196  memcpy (v, &a, sizeof(double));
2197  return is_nan (v);
2198  }
2199 
2201  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2202  static HPS_INLINE bool IsAbnormal(double const & a) {
2203  uint32_t v[2];
2204  memcpy (v, &a, sizeof(double));
2205  return is_special (v);
2206  }
2207 
2210  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2211  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2212 
2213 #ifndef HOOPS_DEFINED
2214  template <typename Alloc>
2215  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2216  {
2217  if (a.size() != b.size())
2218  return false;
2219 
2220  auto it1 = a.begin();
2221  auto it2 = b.begin();
2222  auto const end = a.end();
2223  for ( ; it1 != end; ++it1, ++it2)
2224  {
2225  if (!Equals(*it1, *it2, tolerance))
2226  return false;
2227  }
2228  return true;
2229  }
2230 #endif
2231 
2232  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2233  return extract_uint32_t(a) & 0x80000000;
2234  }
2235  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2236  uint32_t v[2];
2237  memcpy (v, &a, sizeof(double));
2238  return v[High] & 0x80000000;
2239  }
2240 
2241  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2242  uint32_t v = extract_uint32_t(a);
2243  v &= 0x7FFFFFFF;
2244  v |= sign_bit;
2245  inject_uint32_t(a, v);
2246  }
2247  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2248  uint32_t v[2];
2249  memcpy (v, &a, sizeof(double));
2250  v[High] &= 0x7FFFFFFF;
2251  v[High] |= sign_bit;
2252  memcpy (&a, v, sizeof(double));
2253  }
2254 
2255 
2256  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2257  uint32_t v = extract_uint32_t(a);
2258 
2259  v &= 0x7FFFFFFF;
2260  if (v < 0x3B800000)
2261  return 0;
2262 
2263  v--;
2264 
2265  uint32_t exp = v >> 23;
2266  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2267 
2268  return (unsigned char) (man >> (16 + 126 - exp));
2269  }
2270 
2271  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2272  uint32_t v = extract_uint32_t(a);
2273 
2274  v &= 0x7FFFFFFF;
2275  if (v < 0x3B800000)
2276  return 0;
2277 
2278  v--;
2279 
2280  uint32_t exp = v >> 23;
2281  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2282 
2283  uint32_t x = (man >> (16 + 126 - exp));
2284 
2285  return (unsigned char) ((x * (mix+1)) >> 8);
2286  }
2287 
2288 
2289  static HPS_INLINE bool match(float const & a, float const & b) {
2290  uint32_t va = extract_uint32_t(a);
2291  uint32_t vb = extract_uint32_t(b);
2292 
2293  if (((va | vb) & 0x7FFFFFFF) == 0)
2294  return true;
2295 
2296  return va == vb;
2297  }
2298  static HPS_INLINE bool match(double const & a, double const & b) {
2299  return a == b;
2300  }
2301 
2302 
2303  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2304  uint32_t va = extract_uint32_t(a);
2305  uint32_t vb = extract_uint32_t(b);
2306 
2307  uint32_t a_sign = va & 0x80000000;
2308  uint32_t b_sign = vb & 0x80000000;
2309 
2310  (int32_t&)a_sign >>= 31;
2311  (int32_t&)b_sign >>= 31;
2312 
2313  uint32_t mash = (a_sign&b_sign);
2314 
2315  va ^= mash;
2316  vb ^= mash;
2317 
2318  if ((int32_t&)vb < (int32_t&)va)
2319  memcpy(&a, &b, sizeof(float));
2320  }
2321  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2322  if (b < a)
2323  a = b;
2324  }
2325 
2326  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2327  uint32_t va = extract_uint32_t(a);
2328  uint32_t vb = extract_uint32_t(b);
2329 
2330  uint32_t a_sign = va & 0x80000000;
2331  uint32_t b_sign = vb & 0x80000000;
2332 
2333  (int32_t&)a_sign >>= 31;
2334  (int32_t&)b_sign >>= 31;
2335 
2336  uint32_t mash = (a_sign&b_sign);
2337 
2338  va ^= mash;
2339  vb ^= mash;
2340 
2341  if ((int32_t&)vb > (int32_t&)va)
2342  memcpy(&a, &b, sizeof(float));
2343  }
2344  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2345  if (b > a)
2346  a = b;
2347  }
2348 
2349 
2350  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2351  uint32_t i;
2352  memcpy(&i, &a, sizeof(float));
2353  return i;
2354  }
2355 
2356  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2357  memcpy(&a, &i, sizeof(float));
2358  }
2359 
2360  static HPS_INLINE float C2F(unsigned char x) {
2361  //return (float)x * (1.0f/255.0f);
2362  return char_to_float[x];
2363  }
2364 
2365 
2366  // SSE convenience functions
2367  static HPS_INLINE void pack_4(float const & f, float * m) {
2368  memcpy(&m[0], &f, sizeof(float));
2369  memcpy(&m[1], &f, sizeof(float));
2370  memcpy(&m[2], &f, sizeof(float));
2371  memcpy(&m[3], &f, sizeof(float));
2372  }
2373 
2374  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2375  memcpy(&m[0], &f0, sizeof(float));
2376  memcpy(&m[1], &f1, sizeof(float));
2377  memcpy(&m[2], &f2, sizeof(float));
2378  memcpy(&m[3], &f3, sizeof(float));
2379  }
2380 
2381  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2382  memcpy(f0, m, sizeof(float)*4);
2383  }
2384 
2385  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2386  memcpy(&f0, &m[0], sizeof(float));
2387  memcpy(&f1, &m[1], sizeof(float));
2388  memcpy(&f2, &m[2], sizeof(float));
2389  memcpy(&f3, &m[3], sizeof(float));
2390  }
2391 
2392 private:
2393  static const float char_to_float[256];
2394 
2395  Float();
2396 };
2397 
2398 
2400 
2401 
2402 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2403 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2404 
2405 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2406 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2407 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2408 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2409 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2410 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2411 
2412 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2413 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2414 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); }
2415 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); }
2416 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); }
2417 
2418 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2419 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2420 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); }
2421 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); }
2422 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); }
2423 
2424 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; }
2425 
2426 
2427 template <> HPS_INLINE float Abs<float> (float const & a) {
2428  uint32_t v = Float::extract_uint32_t(a);
2429  v &= 0x7FFFFFFF;
2430  float f;
2431  Float::inject_uint32_t(f,v);
2432  return f;
2433 }
2434 
2435 template <> HPS_INLINE int Sign<float> (float const & a) {
2436  uint32_t v = Float::extract_uint32_t(a);
2437 
2438  if ((v & 0x7FFFFFFF) == 0)
2439  return 0;
2440 
2441  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2442 }
2443 
2444 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2445  int a_sign = Sign(a);
2446  int b_sign = Sign(b);
2447 
2448  if (a_sign != b_sign)
2449  return Compare(a_sign, b_sign);
2450 
2451  uint32_t v = Float::extract_uint32_t(a);
2452  uint32_t u = Float::extract_uint32_t(b);
2453 
2454  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2455 }
2456 
2457 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2458  if (Compare(a,b)>0)
2459  return b;
2460  return a;
2461 }
2462 
2463 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2464  if (Compare(a,b)>0)
2465  return a;
2466  return b;
2467 }
2468 
2469 
2471 
2472 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2473  int32_t va = Float::extract_uint32_t(a);
2474  int32_t vb = Float::extract_uint32_t(b);
2475 
2476  if (is_special(va) || is_special(vb)) {
2477  if (is_infinite(va) || is_infinite(vb))
2478  return va == vb; // final check is for sign bits same
2479  if (is_nan(va) || is_nan(vb))
2480  return false;
2481  }
2482 
2483  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2484  if ((va & 0x7FFFFFFF) == 0)
2485  return (vb & 0x7FFFFFFF) < close_to_zero;
2486  else if ((vb & 0x7FFFFFFF) == 0)
2487  return (va & 0x7FFFFFFF) < close_to_zero;
2488 
2489  uint32_t sign_mask = va ^ vb;
2490  (int32_t &)sign_mask >>= 31;
2491 
2492  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2493  int32_t v1 = tolerance + diff;
2494  int32_t v2 = tolerance - diff;
2495  return (v1|v2) >= 0;
2496 }
2497 
2498 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2499  int32_t va[2], vb[2];
2500  memcpy (va, &a, sizeof(double));
2501  memcpy (vb, &b, sizeof(double));
2502 
2503  if (is_special(va) || is_special(vb)) {
2504  if (is_infinite(va) || is_infinite(vb))
2505  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2506  if (is_nan(va) || is_nan(vb))
2507  return false;
2508  }
2509 
2510  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2511  return Abs(a - b) < 0.000000000000005;
2512 
2513  if (extract_sign_bit(a) != extract_sign_bit(b))
2514  return a == b;
2515 
2516  if (va[High] != vb[High])
2517  return false;
2518 
2519  return Abs(va[Low] - vb[Low]) <= tolerance;
2520 }
2521 
2523 
2524 
2525 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2526 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2527 
2528 template <typename T>
2529 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2530  while (count-- > 0)
2531  if (Is_Abnormal (*t++))
2532  return true;
2533  return false;
2534 }
2535 
2536 template <typename T>
2537 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2538  return count >= 0 && Is_Abnormal((size_t)count, t);
2539 }
2540 
2541 
2543 
2544 
2545 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2546 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2547 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2548 template <typename F> class HPS_TEMPLATE_API Point_2D;
2549 
2550 
2551 template <typename F>
2552 class HPS_TEMPLATE_API Point_3D {
2553  public:
2554  F x;
2555  F y;
2556  F z;
2557 
2558  Point_3D () {}
2559  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2560 
2561  template <typename D>
2562  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2563 
2564  explicit Point_3D (Vector_3D<F> const & v);
2565  explicit Point_3D (Vector_2D<F> const & v);
2566  explicit Point_3D (Point_2D<F> const & that);
2567 
2568  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2569 
2570  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2571  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2572 
2573  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2574  return Float::Equals(x, p.x, in_tolerance) &&
2575  Float::Equals(y, p.y, in_tolerance) &&
2576  Float::Equals(z, p.z, in_tolerance);
2577  }
2578 
2579 
2580  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2581  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2582  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2583  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2584 
2585  F & operator[] (size_t i) { return (&x)[i]; }
2586  F const & operator[] (size_t i) const { return (&x)[i]; }
2587 
2588  Point_3D & operator+= (Vector_3D<F> const & v);
2589  Point_3D & operator-= (Vector_3D<F> const & v);
2590  Point_3D & operator*= (Vector_3D<F> const & v);
2591  Point_3D & operator/= (Vector_3D<F> const & v);
2592  Point_3D const operator* (Vector_3D<F> const & v) const;
2593  Point_3D const operator/ (Vector_3D<F> const & v) const;
2594 
2595  Point_3D & operator+= (Vector_2D<F> const & v);
2596  Point_3D & operator-= (Vector_2D<F> const & v);
2597  Point_3D & operator*= (Vector_2D<F> const & v);
2598  Point_3D & operator/= (Vector_2D<F> const & v);
2599  Point_3D const operator* (Vector_2D<F> const & v) const;
2600  Point_3D const operator/ (Vector_2D<F> const & v) const;
2601 
2602  Vector_3D<F> const operator- (Point_3D const & p) const;
2603 
2604  Point_3D const operator+ (Vector_3D<F> const & v) const;
2605  Point_3D const operator- (Vector_3D<F> const & v) const;
2606 
2607  Point_3D const operator+ (Vector_2D<F> const & v) const;
2608  Point_3D const operator- (Vector_2D<F> const & v) const;
2609 
2610  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2611  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2612 };
2613 
2614 typedef Point_3D<float> Point;
2615 typedef Point_3D<double> DPoint;
2616 
2617 
2618 
2619 template <typename F, typename S>
2620 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)); }
2621 
2622 template <typename F>
2623 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2624  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2625 }
2626 
2627 template <typename F>
2628 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2629  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);
2630 }
2631 
2632 template <typename F>
2633 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2634  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2635 }
2636 
2637 
2638 template <typename F>
2639 class HPS_TEMPLATE_API Point_2D {
2640 public:
2641  F x;
2642  F y;
2643 
2644  Point_2D () {}
2645  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2646 
2647  template <typename D>
2648  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2649 
2650  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2651  explicit Point_2D (Vector_2D<F> const & v);
2652 
2653  Point_2D const operator- () const { return Point_2D (-x, -y); }
2654 
2655  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2656  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2657 
2658  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2659  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2660  }
2661 
2662 
2663  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2664  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2665  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2666  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2667 
2668  F & operator[] (size_t i) { return (&x)[i]; }
2669  F const & operator[] (size_t i) const { return (&x)[i]; }
2670 
2671  Point_2D & operator+= (Vector_2D<F> const & v);
2672  Point_2D & operator-= (Vector_2D<F> const & v);
2673  Point_2D & operator*= (Vector_2D<F> const & v);
2674  Point_2D & operator/= (Vector_2D<F> const & v);
2675  Point_2D const operator* (Vector_2D<F> const & v) const;
2676  Point_2D const operator/ (Vector_2D<F> const & v) const;
2677 
2678  Vector_2D<F> const operator- (Point_2D const & p) const;
2679 
2680  Point_2D const operator+ (Vector_2D<F> const & v) const;
2681  Point_2D const operator- (Vector_2D<F> const & v) const;
2682 
2683  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2684  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2685 };
2686 
2687 typedef Point_2D<float> Point2D;
2688 typedef Point_2D<double> DPoint2D;
2689 
2690 template <typename F>
2691 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2692 
2693 template <typename F, typename S>
2694 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)); }
2695 
2696 template <typename F>
2697 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2698  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2699 }
2700 
2701 template <typename F>
2702 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2703  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);
2704 }
2705 
2706 template <typename F>
2707 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2708  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2709 }
2710 
2711 
2712 template <typename F>
2713 class HPS_TEMPLATE_API Vector_3D {
2714  public:
2715  F x;
2716  F y;
2717  F z;
2718 
2719  Vector_3D () {}
2720  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2721  template <typename D>
2722  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2723  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2724  explicit Vector_3D(Plane_3D<F> const & p);
2725 
2726  explicit Vector_3D (Vector_2D<F> const & that);
2727 
2728  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2729 
2730  bool operator== (Vector_3D const & v) const {
2731  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2732  }
2733  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2734 
2735  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2736  return Float::Equals(x, v.x, in_tolerance) &&
2737  Float::Equals(y, v.y, in_tolerance) &&
2738  Float::Equals(z, v.z, in_tolerance);
2739  }
2740 
2741  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2742  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2743  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2744  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2745 
2746  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2747  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2748  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2749  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2750 
2751  F & operator[] (size_t i) { return (&x)[i]; }
2752  F const & operator[] (size_t i) const { return (&x)[i]; }
2753 
2754  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2755 
2756  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2757 
2758  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2759 
2760  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2761 
2762  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2763  if (check_range) {
2764  F range = Max (Abs (x), Abs (y), Abs (z));
2765  if (range > F(1.0e10))
2766  operator/= (range);
2767  }
2768 
2769  F len = (F)Length();
2770  if (len > epsilon)
2771  operator/= (len);
2772  else
2773  *this = Zero();
2774  return *this;
2775  }
2776  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2777 
2778  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2779  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2780 
2781  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2782 
2783  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2784  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2785  }
2786 
2787 
2788  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2789  return Vector_3D (x * v.x, y * v.y, z * v.z);
2790  }
2791 
2792  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2793  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2794  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2795  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2796  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2797 };
2798 
2799 typedef Vector_3D<float> Vector;
2800 typedef Vector_3D<double> DVector;
2801 
2802 
2803 template <typename F, typename S>
2804 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)); }
2805 
2806 template <typename F>
2807 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2808  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2809 }
2810 
2811 
2812 template <typename F>
2813 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2814 
2815 template <typename F>
2816 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; }
2817 template <typename F>
2818 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; }
2819 
2820 template <typename F>
2821 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); }
2822 
2823 template <typename F>
2824 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); }
2825 template <typename F>
2826 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); }
2827 
2828 template <typename F>
2829 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; }
2830 template <typename F>
2831 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; }
2832 template <typename F>
2833 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); }
2834 template <typename F>
2835 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); }
2836 
2837 
2838 
2839 template <typename F>
2840 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2841  return a + (b - a) * t;
2842 }
2843 
2844 template <typename F>
2845 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2846  return Vector_3D<F>(a + (b - a) * t).Normalize();
2847 }
2848 
2849 
2850 
2851 template <typename F>
2852 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2853  return (p2 - p1).Length();
2854 }
2855 
2856 template <typename F>
2857 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2858  return (p2 - p1).LengthSquared();
2859 }
2860 
2861 template <typename F>
2862 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2863  F p = static_cast<F>((c - b).LengthSquared());
2864  F q = static_cast<F>((c - a).LengthSquared());
2865  F r = static_cast<F>((b - a).LengthSquared());
2866 
2867  return Point_3D<F>(
2868  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2869  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2870 }
2871 
2872 
2873 
2874 template <typename F>
2875 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2876  bool success = true;
2877  for (size_t i = 0; i < count; ++i) {
2878  if (vectors->Normalize() == Vector_3D<F>::Zero())
2879  success = false;
2880  vectors++;
2881  }
2882  return success;
2883 }
2884 
2885 
2886 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2887 
2888 template <typename F>
2889 class HPS_TEMPLATE_API Vector_2D {
2890 public:
2891  F x;
2892  F y;
2893 
2894  Vector_2D () {}
2895  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2896  template <typename D>
2897  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2898 
2899  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2900  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2901  explicit Vector_2D (Plane_2D<F> const & p);
2902 
2903  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2904 
2905  bool operator== (Vector_2D const & v) const {
2906  return Float::match(x, v.x) && Float::match(y, v.y);
2907  }
2908  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2909 
2910  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2911  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2912  }
2913 
2914  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2915  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2916  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2917  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2918 
2919  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2920  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2921  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2922  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2923 
2924  F & operator[] (size_t i) { return (&x)[i]; }
2925  F const & operator[] (size_t i) const { return (&x)[i]; }
2926 
2927  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2928 
2929  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2930 
2931  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2932  if (check_range) {
2933  F range = Max (Abs (x), Abs (y));
2934  if (range > F(1.0e10))
2935  operator/= (range);
2936  }
2937 
2938  F len = (F)Length();
2939  if (len > epsilon)
2940  operator/= (len);
2941  else
2942  *this = Zero();
2943  return *this;
2944  }
2945  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2946 
2947  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2948  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2949 
2950  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2951 
2952 
2953  HPS_INLINE float Cross (Vector_2D const & v) const {
2954  return x * v.y - y * v.x;
2955  }
2956 
2957  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2958  return Vector_2D (x * v.x, y * v.y);
2959  }
2960 
2961  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2962  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2963 
2964  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2965  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
2966 };
2967 
2968 typedef Vector_2D<float> Vector2D;
2970 
2971 template <typename F, typename S>
2972 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)); }
2973 
2974 template <typename F>
2975 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
2976  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2977 }
2978 
2979 
2980 template <typename F>
2981 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
2982 
2983 template <typename F>
2984 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
2985 
2986 template <typename F>
2987 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2988 template <typename F>
2989 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2990 
2991 template <typename F>
2992 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); }
2993 template <typename F>
2994 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); }
2995 
2996 template <typename F>
2997 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
2998 template <typename F>
2999 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3000 
3001 template <typename F>
3002 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); }
3003 template <typename F>
3004 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); }
3005 
3006 
3007 template <typename F>
3008 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3009 template <typename F>
3010 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3011 
3012 template <typename F>
3013 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); }
3014 
3015 template <typename F>
3016 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); }
3017 template <typename F>
3018 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); }
3019 
3020 template <typename F>
3021 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3022 template <typename F>
3023 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3024 template <typename F>
3025 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); }
3026 template <typename F>
3027 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); }
3028 
3029 
3030 
3031 
3032 
3033 template <typename F>
3034 class HPS_TEMPLATE_API Plane_3D {
3035  public:
3036  F a;
3037  F b;
3038  F c;
3039  F d;
3040 
3041  Plane_3D () {}
3042  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3043  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3044  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)) {}
3045  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)) {}
3046  template <typename D>
3047  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3048 
3049  Plane_3D (size_t count, Point_3D<F> const * points) {
3050  if (count >= 3) {
3051  // The 3 coefficients A, B, and C are proportional to the areas of the
3052  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3053 
3054  // run around the polygon, collecting trapezoidal areas
3055  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3056 
3057  // take care of the swing point first
3058  Point_3D<F> const * p0 = &points[count-1];
3059 
3061  Vector_3D<F> normal = Vector_3D<F>::Zero();
3062 
3063  for (size_t i=0; i<count; ++i) {
3064  Point_3D<F> const * p1 = &points[i];
3065 
3066  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3067  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3068  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3069 
3070  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3071 
3072  p0 = p1;
3073  }
3074 
3075  // ("should" always be != 0)
3076  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3077  /* finish finding the average */
3078  double inv_count = 1.0 / (double)count;
3079  ctr *= inv_count;
3080 
3081  *this = Plane_3D(normal, Point_3D<F>(ctr));
3082  return;
3083  }
3084  }
3085 
3086  *this = Plane_3D::Zero();
3087  }
3088 
3089 
3090  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3091 
3092  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3093  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3094 
3095  F & operator[] (size_t i) { return (&a)[i]; }
3096  F const & operator[] (size_t i) const { return (&a)[i]; }
3097 
3098  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3099  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3100  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3101  }
3102 
3103  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3104  F len = (F)Vector_3D<F>(*this).Length();
3105  if (len > epsilon)
3106  operator/= (len);
3107  else
3108  *this = Zero();
3109  return *this;
3110  }
3111 
3112  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3113  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3114  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3115 
3116  if (val1 >= eps) {
3117  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3118  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3119  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3120  }
3121  else
3122  return p1;
3123  }
3124 
3125  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3126  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3127  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3128 
3129  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));
3130  }
3131 
3132  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3133 
3134 
3135  private:
3136  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3137  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3138  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3139  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3140 };
3141 
3142 typedef Plane_3D<float> Plane;
3143 typedef Plane_3D<double> DPlane;
3144 
3145 
3146 template <typename F>
3147 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3148  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3149 }
3150 
3151 
3152 template <typename F>
3153 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3154  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3155 }
3156 template <typename F>
3157 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3158  return plane * point;
3159 }
3160 
3161 template <typename F>
3162 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3163  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);
3164 }
3165 
3166 template <typename F>
3167 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3168 
3169 
3170 
3171 
3172 
3173 
3174 template <typename F>
3175 class HPS_TEMPLATE_API Plane_2D {
3176 public:
3177  F a;
3178  F b;
3179  F c;
3180 
3181  Plane_2D () {}
3182  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3183  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3184  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)) {}
3185  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)) {}
3186  template <typename D>
3187  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3188 
3189  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3190 
3191  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3192  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3193 
3194  F & operator[] (size_t i) { return (&a)[i]; }
3195  F const & operator[] (size_t i) const { return (&a)[i]; }
3196 
3197  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3198  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3199  }
3200 
3201  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3202  F len = (F)Vector_2D<F>(*this).Length();
3203  if (len > epsilon)
3204  operator/= (len);
3205  else
3206  *this = Zero();
3207  return *this;
3208  }
3209 
3210  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3211 
3212 
3213 private:
3214  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3215  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3216  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3217  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3218 };
3219 
3220 typedef Plane_2D<float> Plane2D;
3221 typedef Plane_2D<double> DPlane2D;
3222 
3223 
3224 template <typename F>
3225 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3226  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3227 }
3228 
3229 
3230 template <typename F>
3231 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3232  return plane.a * point.x + plane.b * point.y + plane.c;
3233 }
3234 template <typename F>
3235 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3236  return plane * point;
3237 }
3238 
3239 template <typename F>
3240 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3241  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);
3242 }
3243 
3244 template <typename F>
3245 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3246 
3247 
3248 
3249 
3250 struct Rectangle;
3251 
3252 struct HPS_API IntRectangle {
3253  int left;
3254  int right;
3255  int bottom;
3256  int top;
3257 
3258  IntRectangle()
3259  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3260  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3261 
3262  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3263  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3264 
3265  IntRectangle(IntRectangle const & that)
3266  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3267 
3268  explicit IntRectangle(Rectangle const & that);
3269 
3270  bool operator==(IntRectangle const & rect) const {
3271  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3272  }
3273 
3274  bool operator!=(IntRectangle const & rect) const {
3275  return !(*this == rect);
3276  }
3277 
3278  HPS_INLINE int PixelWidth() const {
3279  return right - left + 1;
3280  }
3281 
3282  HPS_INLINE int PixelHeight() const {
3283  return top - bottom + 1;
3284  }
3285 
3286  HPS_INLINE int Width() const {
3287  return right - left;
3288  }
3289 
3290  HPS_INLINE int Height() const {
3291  return top - bottom;
3292  }
3293 
3294  HPS_INLINE int Area() const {
3295  return Width() * Height();
3296  }
3297 
3298  HPS_INLINE Point2D Center() const {
3299  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3300  }
3301 
3302  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3303  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3304  }
3305 
3306  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3307  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3308  }
3309 
3310  HPS_INLINE IntRectangle & Expand(int border) {
3311  left -= border;
3312  right += border;
3313  bottom -= border;
3314  top += border;
3315  return *this;
3316  }
3317 
3318  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3319  left -= rect.left;
3320  right += rect.right;
3321  bottom -= rect.bottom;
3322  top += rect.top;
3323  return *this;
3324  }
3325 
3326  HPS_INLINE IntRectangle & Contract(int border) {
3327  left += border;
3328  right -= border;
3329  bottom += border;
3330  top -= border;
3331  return *this;
3332  }
3333 
3334  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3335  left += rect.left;
3336  right -= rect.right;
3337  bottom += rect.bottom;
3338  top -= rect.top;
3339  return *this;
3340  }
3341 
3342  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3343  left = Max(left, rect.left);
3344  right = Min(right, rect.right);
3345  bottom = Max(bottom, rect.bottom);
3346  top = Min(top, rect.top);
3347  return *this;
3348  }
3349 
3350  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3351  left = Min(left, rect.left);
3352  right = Max(right, rect.right);
3353  bottom = Min(bottom, rect.bottom);
3354  top = Max(top, rect.top);
3355  return *this;
3356  }
3357 
3358 
3359  static HPS_INLINE IntRectangle Invalid() {
3360  return IntRectangle();
3361  }
3362 
3363  static HPS_INLINE IntRectangle Zero() {
3364  return IntRectangle(0, 0, 0, 0);
3365  }
3366 
3367 };
3368 
3369 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3370  IntRectangle temp = a;
3371  return temp.Expand(border);
3372 }
3373 
3374 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3375  IntRectangle temp = a;
3376  return temp.Expand(border);
3377 }
3378 
3379 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3380  IntRectangle temp = a;
3381  return temp.Contract(border);
3382 }
3383 
3384 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3385  IntRectangle temp = a;
3386  return temp.Contract(border);
3387 }
3388 
3389 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3390  IntRectangle temp = a;
3391  return temp.Intersect(b);
3392 }
3393 
3394 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3395  IntRectangle temp = a;
3396  return temp.Union(b);
3397 }
3398 
3399 struct HPS_API Rectangle {
3400  float left;
3401  float right;
3402  float bottom;
3403  float top;
3404 
3405  Rectangle()
3406  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3407  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3408 
3409  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3410  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3411 
3412  Rectangle(Rectangle const & that)
3413  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3414 
3415  explicit Rectangle(IntRectangle const & that)
3416  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3417 
3418  HPS_INLINE Rectangle(size_t count, Point const * points) {
3419  left = points->x;
3420  right = points->x;
3421  top = points->y;
3422  bottom = points->y;
3423  --count;
3424  if (count > 0) {
3425  ++points;
3426  Merge(count, points);
3427  }
3428  }
3429 
3430  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3431  left = points->x;
3432  right = points->x;
3433  top = points->y;
3434  bottom = points->y;
3435  --count;
3436  if (count > 0) {
3437  ++points;
3438  Merge(count, points);
3439  }
3440  }
3441 
3442  HPS_INLINE float Width() const {
3443  return right - left;
3444  }
3445 
3446  HPS_INLINE float Height() const {
3447  return top - bottom;
3448  }
3449 
3450  HPS_INLINE float Area() const {
3451  return Width() * Height();
3452  }
3453 
3454  HPS_INLINE Point2D Center() const {
3455  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3456  }
3457 
3458  HPS_INLINE void Merge(size_t count, Point const * points) {
3459 
3460  while (count > 1) {
3461  if (Compare(points[0].x, points[1].x)>0) {
3462  Float::replace_if_smaller(left, points[1].x);
3463  Float::replace_if_larger(right, points[0].x);
3464  }
3465  else {
3466  Float::replace_if_smaller(left, points[0].x);
3467  Float::replace_if_larger(right, points[1].x);
3468  }
3469 
3470  if (Compare(points[0].y, points[1].y)>0) {
3471  Float::replace_if_smaller(bottom, points[1].y);
3472  Float::replace_if_larger(top, points[0].y);
3473  }
3474  else {
3475  Float::replace_if_smaller(bottom, points[0].y);
3476  Float::replace_if_larger(top, points[1].y);
3477  }
3478 
3479  points += 2;
3480  count -= 2;
3481  }
3482 
3483  if (count > 0)
3484  Merge(*points);
3485  }
3486 
3487  HPS_INLINE void Merge(Point const & point) {
3488  Float::replace_if_smaller(left, point.x);
3489  Float::replace_if_smaller(bottom, point.y);
3490  Float::replace_if_larger(right, point.x);
3491  Float::replace_if_larger(top, point.y);
3492  }
3493 
3494  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3495 
3496  while (count > 1) {
3497  if (Compare(points[0].x, points[1].x)>0) {
3498  Float::replace_if_smaller(left, points[1].x);
3499  Float::replace_if_larger(right, points[0].x);
3500  }
3501  else {
3502  Float::replace_if_smaller(left, points[0].x);
3503  Float::replace_if_larger(right, points[1].x);
3504  }
3505 
3506  if (Compare(points[0].y, points[1].y)>0) {
3507  Float::replace_if_smaller(bottom, points[1].y);
3508  Float::replace_if_larger(top, points[0].y);
3509  }
3510  else {
3511  Float::replace_if_smaller(bottom, points[0].y);
3512  Float::replace_if_larger(top, points[1].y);
3513  }
3514 
3515  points += 2;
3516  count -= 2;
3517  }
3518 
3519  if (count > 0)
3520  Merge(*points);
3521  }
3522 
3523  HPS_INLINE void Merge(Point2D const & point) {
3524  Float::replace_if_smaller(left, point.x);
3525  Float::replace_if_smaller(bottom, point.y);
3526  Float::replace_if_larger(right, point.x);
3527  Float::replace_if_larger(top, point.y);
3528  }
3529 
3530  bool operator==(Rectangle const & rect) const {
3531  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3532  }
3533 
3534  bool operator!=(Rectangle const & rect) const {
3535  return !(*this == rect);
3536  }
3537 
3538  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3539  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3540  }
3541 
3542  HPS_INLINE bool Contains(Point const & contained) const {
3543  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3544  }
3545 
3546  HPS_INLINE bool Contains(Point2D const & contained) const {
3547  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3548  }
3549 
3550  HPS_INLINE bool Contains(Rectangle const & rect) {
3551  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3552  }
3553 
3554  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3555  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3556  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3557  }
3558 
3559  HPS_INLINE Rectangle & Expand(float border) {
3560  left -= border;
3561  right += border;
3562  bottom -= border;
3563  top += border;
3564  return *this;
3565  }
3566 
3567  HPS_INLINE Rectangle & Expand(int border) {
3568  Expand((float)border);
3569  return *this;
3570  }
3571 
3572  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3573  left -= rect.left;
3574  right += rect.right;
3575  bottom -= rect.bottom;
3576  top += rect.top;
3577  return *this;
3578  }
3579 
3580  HPS_INLINE Rectangle & Contract(int border) {
3581  left += border;
3582  right -= border;
3583  bottom += border;
3584  top -= border;
3585  return *this;
3586  }
3587 
3588  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3589  left += rect.left;
3590  right -= rect.right;
3591  bottom += rect.bottom;
3592  top -= rect.top;
3593  return *this;
3594  }
3595 
3596  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3597  left = Max(left, rect.left);
3598  right = Min(right, rect.right);
3599  bottom = Max(bottom, rect.bottom);
3600  top = Min(top, rect.top);
3601  return *this;
3602  }
3603 
3604  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3605  left = Min(left, rect.left);
3606  right = Max(right, rect.right);
3607  bottom = Min(bottom, rect.bottom);
3608  top = Max(top, rect.top);
3609  return *this;
3610  }
3611 
3612  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3613  float scale = (scope.right - scope.left) * 0.5f;
3614  float trans = (scope.right + scope.left) * 0.5f;
3615 
3616  left = left * scale + trans;
3617  right = right * scale + trans;
3618 
3619  scale = (scope.top - scope.bottom) * 0.5f;
3620  trans = (scope.top + scope.bottom) * 0.5f;
3621 
3622  bottom = bottom * scale + trans;
3623  top = top * scale + trans;
3624  return *this;
3625  }
3626 
3627  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3628  float tmp = 2.0f/(scope.right - scope.left);
3629  right = (right - scope.left) * tmp - 1.0f;
3630  left = (left - scope.left) * tmp - 1.0f;
3631 
3632  tmp = 2.0f/(scope.top - scope.bottom);
3633  top = (top - scope.bottom) * tmp - 1.0f;
3634  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3635  return *this;
3636  }
3637 
3638  static HPS_INLINE Rectangle FullScope() {
3639  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3640  }
3641 
3642  static HPS_INLINE Rectangle InvalidScope() {
3643  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3644  }
3645 
3646  static HPS_INLINE Rectangle Zero() {
3647  return Rectangle(0, 0, 0, 0);
3648  }
3649 
3650 };
3651 
3652 
3653 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3654  IntRectangle temp;
3655  temp.left = Floor (a.left);
3656  temp.right = Floor (a.right);
3657  temp.bottom = Floor (a.bottom);
3658  temp.top = Floor (a.top);
3659  return temp;
3660 }
3661 
3662 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3663  Rectangle temp = a;
3664  return temp.Expand(border);
3665 }
3666 
3667 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3668  Rectangle temp = a;
3669  return temp.Expand(border);
3670 }
3671 
3672 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3673  Rectangle temp = a;
3674  return temp.Contract(border);
3675 }
3676 
3677 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3678  Rectangle temp = a;
3679  return temp.Contract(border);
3680 }
3681 
3682 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3683  Rectangle temp = a;
3684  return temp.Intersect(b);
3685 }
3686 
3687 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3688  Rectangle temp = a;
3689  return temp.Union(b);
3690 }
3691 
3692 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3693  Rectangle temp = a;
3694  return temp.Inscribe_Scope(scope);
3695 }
3696 
3697 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3698  Rectangle temp = a;
3699  return temp.Circumscribe_Scope(scope);
3700 }
3701 
3702 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3703  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3704 
3705 
3706 
3707 
3708 template <typename F>
3709 struct Sphere_3D;
3710 
3711 template <typename F>
3712 struct HPS_TEMPLATE_API Cuboid_3D {
3717 
3718 
3722  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3723 
3724  template <typename D>
3725 
3730  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3731 
3732 
3737  Cuboid_3D (Sphere_3D<F> const & that);
3738 
3744  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3745 
3751  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3752  if (count == 0) {
3753  min = Limit_Point();
3754  max = -Limit_Point();
3755  return;
3756  }
3757  min = max = *points++;
3758  --count;
3759  if (count>0)
3760  Merge(count, points);
3761  }
3762 
3767  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3768 
3772  HPS_INLINE bool IsValid() const {
3773  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3774  }
3775 
3779  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3780 
3784  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3785 
3790  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3791 
3796  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3797 
3802  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3803  points[0] = Point_3D<F> (min.x, min.y, min.z);
3804  points[1] = Point_3D<F> (min.x, min.y, max.z);
3805  points[2] = Point_3D<F> (min.x, max.y, min.z);
3806  points[3] = Point_3D<F> (min.x, max.y, max.z);
3807  points[4] = Point_3D<F> (max.x, min.y, min.z);
3808  points[5] = Point_3D<F> (max.x, min.y, max.z);
3809  points[6] = Point_3D<F> (max.x, max.y, min.z);
3810  points[7] = Point_3D<F> (max.x, max.y, max.z);
3811  }
3812 
3816  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3817 
3821  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3822 
3828  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3829  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3830  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3831  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3832  }
3833 
3839  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3840  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3841  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3842  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3843  }
3844 
3851  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3852  //ASSERT (0 <= dimension && dimension <= 2);
3853  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3854  }
3855 
3863  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3864  //ASSERT (0 <= dimension && dimension <= 2);
3865  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3866  }
3867 
3874  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
3875  return LineIntersecting(start, direction, true);
3876  }
3877 
3884  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
3885  Vector_3D<F> const direction = point2 - point1;
3886  return LineIntersecting(point1, direction, false);
3887  }
3888 
3894  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3895  Float::replace_if_smaller(min.x, cuboid.min.x);
3896  Float::replace_if_smaller(min.y, cuboid.min.y);
3897  Float::replace_if_smaller(min.z, cuboid.min.z);
3898  Float::replace_if_larger(max.x, cuboid.max.x);
3899  Float::replace_if_larger(max.y, cuboid.max.y);
3900  Float::replace_if_larger(max.z, cuboid.max.z);
3901  }
3902 
3908  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3909 
3915  HPS_INLINE void Merge(Point_3D<F> const & point) {
3916  Float::replace_if_smaller(min.x, point.x);
3917  Float::replace_if_smaller(min.y, point.y);
3918  Float::replace_if_smaller(min.z, point.z);
3919  Float::replace_if_larger(max.x, point.x);
3920  Float::replace_if_larger(max.y, point.y);
3921  Float::replace_if_larger(max.z, point.z);
3922  }
3923 
3930  void Merge(size_t count, Point_3D<F> const * points) {
3931  while (count > 1) {
3932  if (Compare(points[0].x, points[1].x)>0) {
3933  Float::replace_if_smaller(min.x, points[1].x);
3934  Float::replace_if_larger(max.x, points[0].x);
3935  }
3936  else {
3937  Float::replace_if_smaller(min.x, points[0].x);
3938  Float::replace_if_larger(max.x, points[1].x);
3939  }
3940 
3941  if (Compare(points[0].y, points[1].y)>0) {
3942  Float::replace_if_smaller(min.y, points[1].y);
3943  Float::replace_if_larger(max.y, points[0].y);
3944  }
3945  else {
3946  Float::replace_if_smaller(min.y, points[0].y);
3947  Float::replace_if_larger(max.y, points[1].y);
3948  }
3949 
3950  if (Compare(points[0].z, points[1].z)>0) {
3951  Float::replace_if_smaller(min.z, points[1].z);
3952  Float::replace_if_larger(max.z, points[0].z);
3953  }
3954  else {
3955  Float::replace_if_smaller(min.z, points[0].z);
3956  Float::replace_if_larger(max.z, points[1].z);
3957  }
3958 
3959  points += 2;
3960  count -= 2;
3961  }
3962 
3963  if (count > 0)
3964  Merge(*points);
3965  }
3966 
3972  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
3973  return (contained.min.x >= min.x &&
3974  contained.min.y >= min.y &&
3975  contained.min.z >= min.z &&
3976  contained.max.x <= max.x &&
3977  contained.max.y <= max.y &&
3978  contained.max.z <= max.z);
3979  }
3980 
3986  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
3987  return (contained.x >= min.x &&
3988  contained.y >= min.y &&
3989  contained.z >= min.z &&
3990  contained.x <= max.x &&
3991  contained.y <= max.y &&
3992  contained.z <= max.z);
3993  }
3994 
4001  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4002  return (contained.x >= min.x - epsilon &&
4003  contained.y >= min.y - epsilon &&
4004  contained.z >= min.z - epsilon &&
4005  contained.x <= max.x + epsilon &&
4006  contained.y <= max.y + epsilon &&
4007  contained.z <= max.z + epsilon);
4008  }
4009 
4015  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4016  Float::replace_if_larger(min.x, cuboid.min.x);
4017  Float::replace_if_larger(min.y, cuboid.min.y);
4018  Float::replace_if_larger(min.z, cuboid.min.z);
4019  Float::replace_if_smaller(max.x, cuboid.max.x);
4020  Float::replace_if_smaller(max.y, cuboid.max.y);
4021  Float::replace_if_smaller(max.z, cuboid.max.z);
4022  return *this;
4023  }
4024 
4030  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4031  Float::replace_if_smaller(min.x, cuboid.min.x);
4032  Float::replace_if_smaller(min.y, cuboid.min.y);
4033  Float::replace_if_smaller(min.z, cuboid.min.z);
4034  Float::replace_if_larger(max.x, cuboid.max.x);
4035  Float::replace_if_larger(max.y, cuboid.max.y);
4036  Float::replace_if_larger(max.z, cuboid.max.z);
4037  return *this;
4038  }
4039 
4045  HPS_INLINE Cuboid_3D & Expand(F border) {
4046  Vector_3D<F> delta (border, border, border);
4047  min -= delta;
4048  max += delta;
4049  return *this;
4050  }
4051 
4057  HPS_INLINE Cuboid_3D & Contract(F border) {
4058  Vector_3D<F> delta (border, border, border);
4059  min += delta;
4060  max -= delta;
4061  return *this;
4062  }
4063 
4064 private:
4065  HPS_INLINE static Point_3D<F> Limit_Point () {
4066  F const limit = std::numeric_limits<F>::max();
4067  return Point_3D<F> (limit, limit, limit);
4068  }
4069 
4070  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4071 };
4072 
4073 typedef Cuboid_3D<float> SimpleCuboid;
4074 typedef Cuboid_3D<double> DSimpleCuboid;
4075 
4076 
4077 template <typename F>
4078 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4079  Cuboid_3D<F> temp = a;
4080  return temp.Intersect(b);
4081 }
4082 
4083 template <typename F>
4084 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4085  Cuboid_3D<F> temp = a;
4086  return temp.Union(b);
4087 }
4088 
4089 template <typename F>
4090 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4091  Cuboid_3D<F> temp = a;
4092  return temp.Expand(border);
4093 }
4094 
4095 template <typename F>
4096 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4097  Cuboid_3D<F> temp = a;
4098  return temp.Contract(border);
4099 }
4100 
4101 
4102 
4103 template <typename F>
4104 struct HPS_TEMPLATE_API Sphere_3D {
4105  Point_3D<F> center;
4106  F radius;
4107 
4108  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4109 
4110  template <typename D>
4111  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4112 
4113  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4114  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4115 
4116  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4117 
4118  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4119  Cuboid_3D<F> cuboid(count, points);
4120  center = Midpoint(cuboid.min, cuboid.max);
4121  Engulf (count, points);
4122  }
4123 
4124  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4125  Engulf (count, points);
4126  }
4127 
4128  HPS_INLINE bool IsValid() const {
4129  return radius >= 0;
4130  }
4131 
4132  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4133 
4134  void Invalidate() {radius = -1;}
4135 
4136  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4137  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4138 
4139  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4140 
4141  HPS_INLINE void Merge(Point_3D<F> const & point) {
4142  Vector_3D<F> dir = point - center;
4143  F distance = (F)dir.Length();
4144 
4145  if (distance > radius) {
4146  F t = F(0.5) * (distance - radius);
4147  center += t * dir.Normalize();
4148  radius += t;
4149  }
4150  }
4151 
4152  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4153 
4154  for (size_t i = 0; i < count; ++i) {
4155  Vector_3D<F> dir = *points - center;
4156  F distance = (F)dir.Length();
4157 
4158  if (distance > radius) {
4159  F t = F(0.5) * (distance - radius);
4160  center += t * dir.Normalize();
4161  radius += t;
4162  }
4163 
4164  ++points;
4165  }
4166  }
4167 
4168  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4169  Vector_3D<F> dir = sphere.center - center;
4170  F distance = (F)dir.Length();
4171 
4172  if (distance + sphere.radius > radius) {
4173  if (distance + radius > sphere.radius) {
4174  F t = F(0.5 * (sphere.radius + distance - radius));
4175  center += t * dir.Normalize();
4176  radius += t;
4177  }
4178  else {
4179  center = sphere.center;
4180  radius = sphere.radius;
4181  }
4182  }
4183  }
4184 
4185  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4186 
4187 private:
4188  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4189  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4190  for (size_t i = 0; i < count; ++i) {
4191  double dsq = (*points++ - center).LengthSquared();
4192  if ((F)dsq > radius * radius)
4193  radius = (F)sqrt(dsq);
4194  }
4195  }
4196 };
4197 
4198 typedef Sphere_3D<float> SimpleSphere;
4199 typedef Sphere_3D<double> DSimpleSphere;
4200 
4201 
4202 template <typename F>
4203 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4204  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4205  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4206 }
4207 
4208 
4209 
4210 
4211 class RGB24Color;
4212 class RGBA32Color;
4213 class RGBAS32Color;
4214 class RGBAColor;
4215 
4216 class HPS_API RGBColor {
4217 public:
4218  float red;
4219  float green;
4220  float blue;
4221 
4222  HPS_INLINE RGBColor () {}
4223  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4224  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4225  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4226  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4227  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4228  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4229 
4230  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4231  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4232  float Distance(RGBColor const & other_color) const;
4233  HPS_INLINE bool IsValid() const {
4234  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4235  }
4236 
4237  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4238  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4239 
4240  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4241  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4242 
4243  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4244  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4245  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4246  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4247  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4248  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4249 
4250  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4251  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4252  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4253  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4254  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4255  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4256  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4257  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4258 
4259  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4260  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4261  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4262 
4263  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4264  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4265  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4266 
4267  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4268  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4269  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4270 };
4271 
4272 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4273 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4274 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4275 
4276 
4277 class HPS_API RGBAColor {
4278 public:
4279 
4280  float red;
4281  float green;
4282  float blue;
4283  float alpha;
4285  HPS_INLINE RGBAColor () {}
4286  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4287  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4288 
4289  HPS_INLINE RGBAColor (RGBColor const & c) {
4290  memcpy(this, &c, sizeof(RGBColor)); //-V512
4291  alpha = 1.0f;
4292  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4293  }
4294  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4295  memcpy(this, &c, sizeof(RGBColor));
4296  memcpy(&alpha, &a, sizeof(float));
4297  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4298  }
4299  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4300  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4301 
4302  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4303  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4304  HPS_INLINE bool IsValid() const {
4305  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4306  }
4307 
4314  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4315 
4322  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4323 
4324  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4325  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4326  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4327  }
4328 
4329  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4330  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4331  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4332  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4333  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4334  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4335 
4336  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4337  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4338  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4339  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4340  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4341  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4342  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4343  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4344 
4345  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4346  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4347  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4348  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4349  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4350  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4351 
4352  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4353  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4354  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4355  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4356 };
4357 
4358 
4359 
4361 public:
4362  enum Order {
4363  Order_ABGR,
4364  Order_RGBA,
4365  Order_BGRA
4366  };
4367 
4368 #ifdef _MSC_VER
4369  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4370  unsigned char b, g, r, a;
4371 #endif
4372 
4373 #ifdef __linux__
4374  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4375  unsigned char r, g, b, a;
4376 #endif
4377 
4378 #ifdef __APPLE_CC__
4379  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4380  unsigned char r, g, b, a;
4381 #endif
4382 };
4383 
4384 
4385 
4387 public:
4388 
4389  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4390  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4391  r = gray;
4392  g = gray;
4393  b = gray;
4394  a = aa;
4395  }
4396  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4397  r = rr;
4398  g = gg;
4399  b = bb;
4400  a = aa;
4401  }
4402  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4403 
4404  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4405  {
4406  r = Float::unit_to_byte(c.red);
4407  g = Float::unit_to_byte(c.green);
4408  b = Float::unit_to_byte(c.blue);
4409  a = 255;
4410  }
4411 
4412  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4413 
4414  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4415 
4416  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4417  {
4418  r = Float::unit_to_byte(c.red);
4419  g = Float::unit_to_byte(c.green);
4420  b = Float::unit_to_byte(c.blue);
4421  a = Float::unit_to_byte(alpha);
4422  }
4423  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4424  {
4425  r = Float::unit_to_byte(c.red);
4426  g = Float::unit_to_byte(c.green);
4427  b = Float::unit_to_byte(c.blue);
4428  a = aa;
4429  }
4430  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4431  {
4432  r = Float::unit_to_byte(c.red);
4433  g = Float::unit_to_byte(c.green);
4434  b = Float::unit_to_byte(c.blue);
4435  a = Float::unit_to_byte(c.alpha);
4436  }
4437  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4438  {
4439  r = Float::unit_to_byte(c.red);
4440  g = Float::unit_to_byte(c.green);
4441  b = Float::unit_to_byte(c.blue);
4442  a = Float::unit_to_byte_scaled(c.alpha, mix);
4443  }
4444 
4445  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4446  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4447  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4448 
4449  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4450  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4451 
4452  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4453  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4454  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4455 
4456  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4457 };
4458 
4460 public:
4461  unsigned char r;
4462  unsigned char g;
4463  unsigned char b;
4464  unsigned char a;
4465 
4466  HPS_INLINE RGBA32Color () {}
4467  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4468  : r (gray), g (gray), b (gray), a (aa) {}
4469  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4470  : r (rr), g (gg), b (bb), a (aa) {}
4471  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4472  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4473  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4474  r = Float::unit_to_byte(c.red);
4475  g = Float::unit_to_byte(c.green);
4476  b = Float::unit_to_byte(c.blue);
4477  a = 255;
4478  }
4479  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4480  r = Float::unit_to_byte(c.red);
4481  g = Float::unit_to_byte(c.green);
4482  b = Float::unit_to_byte(c.blue);
4483  a = Float::unit_to_byte(alpha);
4484  }
4485  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4486  r = Float::unit_to_byte(c.red);
4487  g = Float::unit_to_byte(c.green);
4488  b = Float::unit_to_byte(c.blue);
4489  a = aa;
4490  }
4491  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4492  r = Float::unit_to_byte(c.red);
4493  g = Float::unit_to_byte(c.green);
4494  b = Float::unit_to_byte(c.blue);
4495  a = Float::unit_to_byte(c.alpha);
4496  }
4497  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4498  r = Float::unit_to_byte(c.red);
4499  g = Float::unit_to_byte(c.green);
4500  b = Float::unit_to_byte(c.blue);
4501  a = Float::unit_to_byte_scaled(c.alpha, mix);
4502  }
4503 
4504  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4505  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4506 
4507  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4508  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4509 
4510  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4511  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4512 
4513  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4514 };
4515 
4516 
4518 {
4519 public:
4520  unsigned char r;
4521  unsigned char g;
4522  unsigned char b;
4523 
4524  HPS_INLINE RGB24Color () {}
4525  explicit HPS_INLINE RGB24Color (unsigned char gray)
4526  : r (gray), g (gray), b (gray) {}
4527  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4528  : r (rr), g (gg), b (bb) {}
4529  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4530  r = Float::unit_to_byte(c.red);
4531  g = Float::unit_to_byte(c.green);
4532  b = Float::unit_to_byte(c.blue);
4533  }
4534 
4535  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4536  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4537 
4538  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4539  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4540 };
4541 
4542 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4543  red = Float::C2F(c32.r);
4544  green = Float::C2F(c32.g);
4545  blue = Float::C2F(c32.b);
4546 }
4547 
4548 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4549  red = Float::C2F(c32.r);
4550  green = Float::C2F(c32.g);
4551  blue = Float::C2F(c32.b);
4552 }
4553 
4554 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4555  red = c.red;
4556  green = c.green;
4557  blue = c.blue;
4558 }
4559 
4560 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4561  red = Float::C2F(c24.r);
4562  green = Float::C2F(c24.g);
4563  blue = Float::C2F(c24.b);
4564 }
4565 
4566 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4567 {
4568  r = c.r;
4569  g = c.g;
4570  b = c.b;
4571  a = 255;
4572 }
4573 
4574 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4575 {
4576  r = c.r;
4577  g = c.g;
4578  b = c.b;
4579  a = c.a;
4580 }
4581 
4582 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4583  red = Float::C2F(c32.r);
4584  green = Float::C2F(c32.g);
4585  blue = Float::C2F(c32.b);
4586  alpha = Float::C2F(c32.a);
4587 }
4588 
4589 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4590  red = Float::C2F(c32.r);
4591  green = Float::C2F(c32.g);
4592  blue = Float::C2F(c32.b);
4593  alpha = Float::C2F(c32.a);
4594 }
4595 
4596 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4597  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4598 }
4599 
4600 
4601 
4602 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4603  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4604 }
4605 
4606 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4607  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);
4608 }
4609 
4610 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4611  return RGBAS32Color(
4612  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4613  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4614  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4615  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4616 }
4617 
4618 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4619  return RGBA32Color(
4620  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4621  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4622  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4623  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4624 }
4625 
4626 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4627  return RGB24Color(
4628  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4629  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4630  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4631 }
4632 
4633 
4634 
4635 class HPS_API Quaternion {
4636 public:
4637  float w;
4638  float x;
4639  float y;
4640  float z;
4641 
4642  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4643 
4644  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) { }
4645 
4646  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4647 
4648  Quaternion const & Normalize() {
4649  float mag = Norm();
4650 
4651  if (mag > 0) {
4652  w /= mag;
4653  x /= mag;
4654  y /= mag;
4655  z /= mag;
4656  }
4657  return *this;
4658  }
4659 
4660 
4661  Quaternion operator* (Quaternion const & in_right) const {
4662  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4663  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4664  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4665  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4666  }
4667 
4668  Quaternion operator* (float in_right) const {
4669  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4670  }
4671 
4672  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4673  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4674  }
4675 
4676  Quaternion operator/ (float in_right) const {
4677  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4678  }
4679 
4680  Quaternion operator- (Quaternion const & in_right) const {
4681  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4682  }
4683 
4684  Quaternion operator+ (Quaternion const & in_right) const {
4685  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4686  }
4687 
4688  inline float Norm() const {
4689  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4690  }
4691 
4692 
4693  Quaternion Log() const {
4694  Quaternion ret;
4695  float mag_q = Norm();
4696  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4697 
4698  ret.w = static_cast<float>(log(mag_q));
4699 
4700  if (mag_V > 0) {
4701  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4702 
4703  ret.x = x * scale;
4704  ret.y = y * scale;
4705  ret.z = z * scale;
4706  }
4707  else
4708  ret.x = ret.y = ret.z = 0;
4709 
4710  return ret;
4711  }
4712 
4713  Quaternion Exp() const {
4714  Quaternion ret;
4715  float ea = static_cast<float>(exp(w));
4716  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4717  float scale = ea * sin(mag_V) / mag_V;
4718 
4719  ret.w = ea * cos(mag_V);
4720  ret.x = scale * x;
4721  ret.y = scale * y;
4722  ret.z = scale * z;
4723 
4724  return ret;
4725  }
4726 
4727  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4728  Quaternion ret = *this + in_fraction * (in_right - *this);
4729  return ret.Normalize();
4730  }
4731 
4732 
4733  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4734  Quaternion q3;
4735  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4736 
4737  if (in_shortest_path_only && dot < 0) {
4738  dot = -dot;
4739  q3 = -1 * in_right;
4740  }
4741  else
4742  q3 = in_right;
4743 
4744  if (dot > -0.95f && dot < 0.95f) {
4745  float angle = static_cast<float>(acos(dot));
4746  float sina = static_cast<float>(sin(angle));
4747  float sinat = static_cast<float>(sin(angle*in_fraction));
4748  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4749 
4750  return (*this * sinaomt + q3 * sinat) / sina;
4751  }
4752  else //if the angle is small, we use linear interpolation
4753  return Lerp(q3, in_fraction);
4754  }
4755 
4756 
4757  /*
4758  Spherical cubic interpolation between two Quaternions
4759  \param in_right The Quaternion for interpolation.
4760  \param in_control1 The first control point.
4761  \param in_control2 The second control point.
4762  \param in_fraction Interpolation distance (0 - 1).
4763  \return Result of interpolation.
4764  */
4765  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4766  Quaternion q1 = Slerp(in_right , in_fraction, false);
4767  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4768 
4769  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4770  }
4771 
4778  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4779  Quaternion qni(-x, -y, -z, w);
4780 
4781  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4782  }
4783 
4784 };
4785 
4787 {
4788  size_t dot_dc_count;
4789  size_t dot_3d_count;
4790  size_t line_dc_count;
4791  size_t line_3d_count;
4792  size_t triangle_dc_count;
4793  size_t triangle_3d_count;
4794  size_t polygon_dc_count;
4795  size_t polygon_3d_count;
4796  size_t polyhedron_count;
4797  size_t deleted_display_list_count;
4798  size_t display_list_line_3d_count;
4799  size_t display_list_triangle_3d_count;
4800  size_t display_list_vertex_3d_count;
4801  size_t display_list_tristrip_count;
4802  size_t non_display_list_tristrip_count;
4803  size_t culled_display_list_tristrip_count;
4804  size_t raster_count;
4805  size_t segment_count;
4806  size_t frustum_culled_segment_count;
4807  size_t extent_culled_segment_count;
4808  size_t vector_culled_segment_count;
4809  Time update_time;
4810 };
4811 
4812 typedef unsigned char byte;
4813 typedef signed char sbyte;
4814 typedef intptr_t WindowHandle;
4815 typedef int64_t TouchID;
4816 typedef intptr_t PlatformData;
4817 
4818 /*
4819 HPS Lexicon:
4820 
4821 Concept Class -- A class that contains only enums and possibly static functions. The
4822  constructor is usually private because they are not intended to be instantiated.
4823 
4824 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4825  database objects is subject to locking to prevent threading deadlocks. (2) The class
4826  of the same name, offering static functions to initiate operations that take place
4827  within the database.
4828 
4829 Key -- A reference counted smart pointer to an object in the database. The
4830 
4831 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4832  option group, or other type. Modifying a kit has no effect on the database unless
4833  and until it is applied. Kits should generally be passed by reference because they
4834  are potentially very large and copying them can be arduous.
4835 
4836 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4837  pointers should generally be passed by value to ensure the reference count is
4838  correct.
4839 
4840 User Space -- The external space occupied by all user code. User space objects are not
4841  in the database and are not subject to locking.
4842 
4843 */
4844 
4848 class SegmentKey;
4849 class AttributesControl;
4850 class LineKit;
4851 class LineKey;
4852 class TextKey;
4853 class TextKit;
4854 class Key;
4855 class VisibilityControl;
4856 class CameraControl;
4857 class SelectabilityControl;
4858 class TransparencyKit;
4859 class TransparencyControl;
4860 class CullingKit;
4861 class CullingControl;
4862 class GlyphKit;
4864 class GlyphDefinition;
4865 class GeometryInsertControl;
4866 class GlyphElement;
4867 class TextAttributeControl;
4868 class TextAttributeKit;
4869 class LineAttributeKit;
4870 class LineAttributeControl;
4871 class EdgeAttributeKit;
4872 class EdgeAttributeControl;
4873 class CurveAttributeKit;
4874 class CurveAttributeControl;
4875 class GlyphPoint;
4876 class MatrixKit;
4878 class TextureMatrixControl;
4879 class TextureDefinition;
4880 class MaterialMappingKit;
4882 class MaterialKit;
4883 class MarkerKit;
4884 class MarkerKey;
4885 class DistantLightKit;
4886 class DistantLightKey;
4887 class CuttingSectionKit;
4888 class CuttingSectionKey;
4891 class CylinderAttributeKit;
4893 class Cylinder;
4894 class CylinderKey;
4895 class CylinderKit;
4896 class SphereKey;
4897 class SphereKit;
4898 class SphereAttributeKit;
4900 class PolygonKit;
4901 class PolygonKey;
4902 class CircleKey;
4903 class CircleKit;
4904 class CircularArcKey;
4905 class CircularArcKit;
4906 class CircularWedgeKey;
4907 class CircularWedgeKit;
4908 class IncludeKey;
4909 class InfiniteLineKey;
4910 class InfiniteLineKit;
4911 class SpotlightKey;
4912 class SpotlightKit;
4913 class NURBSCurveKey;
4914 class NURBSCurveKit;
4915 class NURBSSurfaceKey;
4916 class NURBSSurfaceKit;
4917 class TrimKit;
4918 class TrimElement;
4919 class EllipseKey;
4920 class EllipseKit;
4921 class EllipticalArcKey;
4922 class EllipticalArcKit;
4923 class ShellKit;
4924 class ShellKey;
4925 class Shell;
4926 class MeshKit;
4927 class MeshKey;
4928 class WindowKey;
4929 class Database;
4932 class Driver;
4933 class Search;
4934 class PerformanceKit;
4935 class PerformanceControl;
4938 class DrawingAttributeKit;
4940 class PortfolioKey;
4941 class Selection;
4942 class SelectionOptionsKit;
4943 class SelectionResults;
4944 class SelectionItem;
4945 class SelectionControl;
4946 class HighlightControl;
4947 class HighlightOptionsKit;
4948 class ImageDefinition;
4949 class ImageKit;
4950 class TextureDefinition;
4951 class TextureOptionsKit;
4952 class NamedStyleDefinition;
4954 class GlyphDefinition;
4955 class LinePatternOptionsKit;
4956 class LinePatternDefinition;
4957 class LinePatternKit;
4958 class LinePatternElement;
4960 class CubeMapDefinition;
4961 class ShaderKit;
4962 class ShaderDefinition;
4963 class EmergencyHandler;
4964 class EventDispatcher;
4965 class EventHandler;
4966 class Event;
4967 class StandAloneWindowKey;
4969 class ApplicationWindowKey;
4971 class OffScreenWindowKey;
4974 class VisualEffectsControl;
4977 class ObjectPoint;
4978 class WorldPoint;
4979 class CameraPoint;
4980 class NormalizedPoint;
4981 class ScreenRangePoint;
4982 class InnerWindowPoint;
4983 class InnerPixelPoint;
4984 class WindowPoint;
4985 class PixelPoint;
4986 class VisibilityKit;
4987 class CameraKit;
4988 class SelectabilityKit;
4989 class MarkerAttributeKit;
4990 class LightingAttributeKit;
4991 class VisualEffectsKit;
4992 class PostProcessEffectsKit;
4993 class Portfolio;
4994 class SubwindowControl;
4995 class SubwindowKit;
4996 class World;
4997 class DebuggingControl;
4998 class DebuggingKit;
4999 class KeyPath;
5000 class ContourLineKit;
5001 class ContourLineControl;
5002 class UTF8;
5003 class StyleControl;
5004 class PortfolioControl;
5005 class Condition;
5006 class ConditionControl;
5007 class WindowInfoKit;
5008 class WindowInfoControl;
5009 class FontInfoState;
5010 class FontInfoControl;
5011 class SearchOptionsKit;
5012 class AttributeLockControl;
5013 class AttributeLockKit;
5014 class ReferenceKey;
5015 class StyleKey;
5016 class BoundingKit;
5017 class BoundingControl;
5018 class TransformMaskKit;
5019 class TransformMaskControl;
5020 class ColorInterpolationKit;
5022 class UpdateOptionsKit;
5023 class UpdateOptionsControl;
5024 class GeometryKey;
5025 class TreeContext;
5028 class GridKit;
5029 class GridKey;
5032 
5036 
5037 
5040 class HPS_API GlyphPoint
5041 {
5042 public:
5043 
5045  GlyphPoint();
5046 
5051  GlyphPoint(sbyte in_x, sbyte in_y);
5052 
5057  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5058 
5063  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5064 
5069  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5070 
5071  sbyte x;
5072  sbyte y;
5073 };
5074 
5077 enum class Type : uint32_t
5078 {
5079  None = 0x00000000,
5080  GenericMask = 0xffffff00,
5081 
5082  World = 0x00000001,
5083  UTF8 = 0x00000002,
5084  EventDispatcher = 0x00000003,
5085  EventHandler = 0x00000004,
5086  EventNotifier = 0x00000005,
5087  UpdateNotifier = 0x00000006,
5088  SearchResults = 0x00000008,
5089  FontSearchResults = 0x00000009,
5090  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
5091  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5092  SelectionResults = 0x0000000c,
5093  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5094  SelectionItem = 0x0000000e,
5095  TreeContext = 0x0000000f,
5096  StreamToolkit = 0x00000010,
5097 
5098  IONotifier = 0x04000100,
5099  StreamImportNotifier = 0x04000101,
5100  STLImportNotifier = 0x04000102,
5101  OBJImportNotifier = 0x04000103,
5102  ExchangeImportNotifier = 0x04000104,
5103  SketchupImportNotifier = 0x04000105,
5104  ParasolidImportNotifier = 0x04000106,
5105  ExchangeTranslationNotifier = 0x04000107,
5106  ExchangeExportNotifier = 0x04000108,
5107  StreamExportNotifier = 0x04000109,
5108  ExchangeReloadNotifier = 0x0400010a,
5109  DWGImportNotifier = 0x0400010b,
5110 
5111  Kit = 0x01000000,
5112  MarkerKit = 0x01000010,
5113  SphereAttributeKit = 0x01000011,
5114  TextAttributeKit = 0x01000012,
5115  TransparencyKit = 0x01000013,
5116  VisibilityKit = 0x01000014,
5117  VisualEffectsKit = 0x01000015,
5118  CuttingSectionAttributeKit = 0x01000016,
5119  CircleKit = 0x01000017,
5120  CircularArcKit = 0x01000018,
5121  CircularWedgeKit = 0x01000019,
5122  CuttingSectionKit = 0x0100001a,
5123  CylinderKit = 0x0100001b,
5124  DistantLightKit = 0x0100001c,
5125  EllipseKit = 0x0100001d,
5126  EllipticalArcKit = 0x0100001e,
5127  InfiniteLineKit = 0x0100001f,
5128  LineKit = 0x01000020,
5129  NURBSCurveKit = 0x01000021,
5130  MeshKit = 0x01000022,
5131  NURBSSurfaceKit = 0x01000023,
5132  PolygonKit = 0x01000024,
5133  SphereKit = 0x01000025,
5134  SpotlightKit = 0x01000026,
5135  ShellKit = 0x01000027,
5136  TextKit = 0x01000028,
5137  MaterialKit = 0x01000029,
5138  TrimKit = 0x0100002a,
5139  TextureOptionsKit = 0x0100002c,
5140  LinePatternKit = 0x0100002d,
5141  GlyphKit = 0x0100002e,
5142  ImageKit = 0x0100002f,
5143  LinePatternOptionsKit = 0x01000030,
5144  CameraKit = 0x01000031,
5145  BoundingKit = 0x01000032,
5146  CullingKit = 0x01000033,
5147  CurveAttributeKit = 0x01000034,
5148  CylinderAttributeKit = 0x01000035,
5149  EdgeAttributeKit = 0x01000036,
5150  LightingAttributeKit = 0x01000037,
5151  LineAttributeKit = 0x01000038,
5152  MarkerAttributeKit = 0x01000039,
5153  MaterialMappingKit = 0x0100003a,
5154  MatrixKit = 0x0100003b,
5155  NURBSSurfaceAttributeKit = 0x0100003c,
5156  PostProcessEffectsKit = 0x0100003d,
5157  SelectabilityKit = 0x0100003e,
5158  SelectionOptionsKit = 0x0100003f,
5159  StandAloneWindowOptionsKit = 0x01000040,
5160  OffScreenWindowOptionsKit = 0x01000041,
5161  ApplicationWindowOptionsKit = 0x01000042,
5162  HighlightOptionsKit = 0x01000043,
5163  LinePatternParallelKit = 0x01000044,
5164  SubwindowKit = 0x01000045,
5165  PerformanceKit = 0x01000046,
5166  HiddenLineAttributeKit = 0x01000047,
5167  DrawingAttributeKit = 0x01000048,
5168  ShaderKit = 0x01000049,
5169  DebuggingKit = 0x0100004a,
5170  ContourLineKit = 0x0100004b,
5171  StreamImportOptionsKit = 0x0100004c,
5172  StreamImportResultsKit = 0x0100004d,
5173  StreamExportOptionsKit = 0x0100004e,
5174  StreamExportResultsKit = 0x0100004f,
5175  WindowInfoKit = 0x01000050,
5176  ImageImportOptionsKit = 0x01000051,
5177  SearchOptionsKit = 0x01000052,
5178  ShaderImportOptionsKit = 0x01000053,
5179  HardcopyExportOptionsKit = 0x01000055,
5180  AttributeLockKit = 0x01000056,
5181  TransformMaskKit = 0x01000057,
5182  ColorInterpolationKit = 0x01000058,
5183  UpdateOptionsKit = 0x01000059,
5184  ImageExportOptionsKit = 0x0100005a,
5185  OBJImportOptionsKit = 0x0100005b,
5186  OBJImportResultsKit = 0x0100005c,
5187  STLImportOptionsKit = 0x0100005d,
5188  STLImportResultsKit = 0x0100005e,
5189  ShellOptimizationOptionsKit = 0x0100005f,
5190  ShellRelationOptionsKit = 0x01000060,
5191  ShellRelationResultsKit = 0x01000061,
5192  GridKit = 0x01000062,
5193  CutGeometryGatheringOptionsKit = 0x01000063,
5194  SegmentOptimizationOptionsKit = 0x01000064,
5195 
5196 
5197  LinePatternElement = 0x03000000,
5198  SolidLinePatternElement = 0x03000001,
5199  BlankLinePatternElement = 0x03000002,
5200  GlyphLinePatternElement = 0x03000003,
5201 
5202  GlyphElement = 0x05000000,
5203  DotGlyphElement = 0x05000001,
5204  LineGlyphElement = 0x05000002,
5205  EllipseGlyphElement = 0x05000003,
5206  CircularArcGlyphElement = 0x05000004,
5207  InfiniteLineGlyphElement = 0x05000005,
5208 
5209  TrimElement = 0x07000000,
5210 
5211  Condition = 0x09000000,
5212  NOTCondition = 0x09000001,
5213  ANDCondition = 0x09000002,
5214  ORCondition = 0x09000003,
5215  XORCondition = 0x09000004,
5216  EQCondition = 0x09000005,
5217  NEQCondition = 0x09000006,
5218  GTCondition = 0x09000007,
5219  LTCondition = 0x09000008,
5220  GTEQCondition = 0x09000009,
5221  LTEQCondition = 0x0900000A,
5222 
5223  MouseState = 0x01001001,
5224  TouchState = 0x01001002,
5225  KeyboardState = 0x01001003,
5226  FontInfoState = 0x01001004,
5227 
5228  KeyPath = 0x01000F01,
5229 
5230  Key = 0x10000000,
5231  IncludeKey = 0x10000001,
5232  PortfolioKey = 0x10000002,
5233  StyleKey = 0x10000003,
5234 
5235  SegmentKey = 0x10200000,
5236  WindowKey = 0x10600000,
5237  StandAloneWindowKey = 0x10600001,
5238  OffScreenWindowKey = 0x10600002,
5239  ApplicationWindowKey = 0x10600003,
5240 
5241  GeometryKey = 0x10100000,
5242  ReferenceKey = 0x10100001,
5243  CircleKey = 0x10100002,
5244  CircularArcKey = 0x10100003,
5245  CircularWedgeKey = 0x10100004,
5246  CuttingSectionKey = 0x10100005,
5247  CylinderKey = 0x10100006,
5248  EllipseKey = 0x10100007,
5249  EllipticalArcKey = 0x10100008,
5250  InfiniteLineKey = 0x10100009,
5251  LineKey = 0x1010000a,
5252  DistantLightKey = 0x1010000b,
5253  SpotlightKey = 0x1010000c,
5254  MarkerKey = 0x1010000d,
5255  MeshKey = 0x1010000e,
5256  NURBSCurveKey = 0x1010000f,
5257  NURBSSurfaceKey = 0x10100010,
5258  PolygonKey = 0x10100011,
5259  ShellKey = 0x10100012,
5260  SphereKey = 0x10100013,
5261  TextKey = 0x10100014,
5262  GridKey = 0x10100015,
5263 
5264  Definition = 0x20000000,
5265  NamedStyleDefinition = 0x20000001,
5266  TextureDefinition = 0x20000002,
5267  LinePatternDefinition = 0x20000003,
5268  GlyphDefinition = 0x20000004,
5269  CubeMapDefinition = 0x20000005,
5270  ImageDefinition = 0x20000006,
5271  MaterialPaletteDefinition = 0x20000007,
5272  ShaderDefinition = 0x20000008,
5273 
5274  Control = 0x50000000,
5275  CameraControl = 0x50000001,
5276  SelectabilityControl = 0x50000002,
5277  MarkerAttributeControl = 0x50000003,
5278  SphereAttributeControl = 0x50000004,
5279  LightingAttributeControl = 0x50000005,
5280  CylinderAttributeControl = 0x50000006,
5281  TextAttributeControl = 0x50000007,
5282  LineAttributeControl = 0x50000008,
5283  EdgeAttributeControl = 0x50000009,
5284  CurveAttributeControl = 0x5000000a,
5285  ModellingMatrixControl = 0x5000000b,
5286  TextureMatrixControl = 0x5000000c,
5287  CullingControl = 0x5000000d,
5288  TransparencyControl = 0x5000000e,
5289  MaterialMappingControl = 0x5000000f,
5290  NURBSSurfaceAttributeControl = 0x50000010,
5291  PostProcessEffectsControl = 0x50000011,
5292  BoundingControl = 0x50000012,
5293  VisualEffectsControl = 0x50000013,
5294  SelectionOptionsControl = 0x50000014,
5295  HighlightOptionsControl = 0x50000015,
5296  DefinitionControl = 0x50000016,
5297  SelectionControl = 0x50000017,
5298  HighlightControl = 0x50000018,
5299  StandAloneWindowOptionsControl = 0x50000019,
5300  OffScreenWindowOptionsControl = 0x5000001a,
5301  ApplicationWindowOptionsControl = 0x5000001b,
5302  VisibilityControl = 0x5000001c,
5303  SubwindowControl = 0x5000001d,
5304  PerformanceControl = 0x5000001e,
5305  HiddenLineAttributeControl = 0x5000001f,
5306  DrawingAttributeControl = 0x50000020,
5307  DebuggingControl = 0x50000021,
5308  ContourLineControl = 0x50000022,
5309  StyleControl = 0x50000023,
5310  ConditionControl = 0x50000024,
5311  PortfolioControl = 0x50000025,
5312  WindowInfoControl = 0x50000026,
5313  AttributeLockControl = 0x50000027,
5314  TransformMaskControl = 0x50000028,
5315  ColorInterpolationControl = 0x50000029,
5316  UpdateOptionsControl = 0x50000030,
5317  CuttingSectionAttributeControl = 0x50000031,
5318 
5319  LibraryMask = 0x80FF0000,
5320 
5321  Sprocket = 0x80000000,
5322  Canvas = 0x80000001,
5323  Layout = 0x80000002,
5324  View = 0x80000003,
5325  Model = 0x80000004,
5326  Operator = 0x80000005,
5327  SprocketPath = 0x80000007,
5328 
5329  SprocketControl = 0xD0000000,
5330  OperatorControl = 0xD0000008,
5331  NavigationCubeControl = 0xD0000009,
5332  AxisTriadControl = 0xD000000A,
5333 
5334  Metadata = 0x80001000,
5335  IntegerMetadata = 0x80001001,
5336  UnsignedIntegerMetadata = 0x80001002,
5337  DoubleMetadata = 0x80001003,
5338  StringMetadata = 0x80001004,
5339  TimeMetadata = 0x80001005,
5340  BooleanMetadata = 0x80001006,
5341 
5342  Component = 0x80000200,
5343  Filter = 0x80000600,
5344  Capture = 0x80000a00,
5345  CADModel = 0x80000300,
5346  ComponentPath = 0x81001000,
5347 
5348  ExchangeMask = 0x80020000,
5349  ExchangeComponent = 0x80021200,
5350  ExchangeFilter = 0x80020601,
5351  ExchangeCapture = 0x80020a01,
5352  ExchangeCADModel = 0x80020301,
5353  ExchangeConfiguration = 0x81020001,
5354  ExchangeImportOptionsKit = 0x81020002,
5355  ExchangeExportACISOptionsKit = 0x81020003,
5356  ExchangeExportIGESOptionsKit = 0x81020004,
5357  ExchangeExportJTOptionsKit = 0x81020005,
5358  ExchangeExportParasolidOptionsKit = 0x81020006,
5359  ExchangeExportPRCOptionsKit = 0x81020007,
5360  ExchangeExportSTEPOptionsKit = 0x81020008,
5361  ExchangeExportSTLOptionsKit = 0x81020009,
5362  ExchangeExportU3DOptionsKit = 0x8102000a,
5363  ExchangeExportXMLOptionsKit = 0x8102000b,
5364  ExchangeTessellationOptionsKit = 0x8102000c,
5365  ExchangeSheet = 0x80021201,
5366  ExchangeModelFileImportOptionsKit = 0x8102000d,
5367 
5368  PublishMask = 0x80040000,
5369  PublishDocumentKit = 0x81040001,
5370  PublishPageKit = 0x81040002,
5371  PublishTemplateKit = 0x81040003,
5372  PublishAnnotationKit = 0x81040004,
5373  PublishArtworkKit = 0x81040005,
5374  PublishViewKit = 0x81040006,
5375  PublishTextKit = 0x81040007,
5376  PublishImageKit = 0x81040008,
5377  PublishTableKit = 0x81040009,
5378  PublishExportOptionsKit = 0x8104000a,
5379  PublishLinkKit = 0x8104000b,
5380  PublishButtonKit = 0x8104000c,
5381  PublishTextFieldKit = 0x8104000d,
5382  PublishSlideTableKit = 0x8104000e,
5383  PublishCheckBoxKit = 0x8104000f,
5384  PublishRadioButtonKit = 0x81040010,
5385  PublishListBoxKit = 0x81040011,
5386  PublishDropDownListKit = 0x81040012,
5387  PublishSignatureFieldKit = 0x81040013,
5388 
5389  PublishDocumentKey = 0x80040001,
5390  PublishPageControl = 0x80040002,
5391 
5392  SceneTree = 0x80008001,
5393  SceneTreeItem = 0x80008002,
5394 
5395  ComponentTree = 0x80008003,
5396  ComponentTreeItem = 0x80008004,
5397 
5398  SketchupMask = 0x80100000,
5399  SketchupImportOptionsKit = 0x81100001,
5400  SketchupImportResultsKit = 0x81100002,
5401 
5402  ParasolidMask = 0x80200000,
5403  ParasolidComponent = 0x80201201,
5404  ParasolidCADModel = 0x80200302,
5405  ParasolidImportOptionsKit = 0x81200003,
5406  ParasolidFacetTessellationKit = 0x81200004,
5407  ParasolidLineTessellationKit = 0x81200005,
5408  ParasolidExportOptionsKit = 0x81200006,
5409 
5410  DWGMask = 0x80400000,
5411  DWGComponent = 0x80401200,
5412  DWGCADModel = 0x80400301,
5413  DWGImportOptionsKit = 0x81400002,
5414 
5415  IONotifierData = 0x84000200,
5416  StreamImportNotifierData = 0x84000201,
5417  STLImportNotifierData = 0x84000202,
5418  OBJImportNotifierData = 0x84000203,
5419  ExchangeImportNotifierData = 0x84020204,
5420  SketchupImportNotifierData = 0x84100205,
5421  ParasolidImportNotifierData = 0x84200206,
5422  ExchangeTranslationNotifierData = 0x84020207,
5423  ExchangeExportNotifierData = 0x84020208,
5424  StreamExportNotifierData = 0x84000209,
5425  DWGImportNotifierData = 0x8440020a,
5426 };
5427 
5429 class HPS_API Memory
5430 {
5431 public:
5437  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5438 
5439 
5444  static void Free(void * in_pointer);
5445 
5446 private:
5448  Memory();
5449 };
5450 
5451 
5453 template <typename T>
5454 class NO_HPS_API Allocator
5455 {
5456 public:
5457  typedef T value_type;
5458  typedef value_type * pointer;
5459  typedef value_type const * const_pointer;
5460  typedef value_type & reference;
5461  typedef value_type const & const_reference;
5462  typedef size_t size_type;
5463  typedef ptrdiff_t difference_type;
5464 
5465 
5466  Allocator() {}
5467  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5468  ~Allocator() {}
5469 
5470  template <typename U> Allocator(Allocator<U> const &) {}
5471 
5472  template <typename U>
5473  struct rebind
5474  {
5475  typedef Allocator<U> other;
5476  };
5477 
5478 
5479  pointer address(reference x) const { return &x; }
5480  const_pointer address(const_reference x) const { return &x; }
5481 
5482  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5483  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5484 
5485 #if defined(_MSC_VER) || defined (__APPLE__)
5486  void construct(pointer p, const_reference x) { new(p) T(x); }
5487 #else
5488  template<typename U, typename... Args>
5489  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5490 #endif
5491  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5492 
5493  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5494 };
5495 
5496 template <typename T, typename U>
5497 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5498 
5499 template <typename T, typename U>
5500 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5501 
5503 class Exception : public std::runtime_error
5504 {
5505 public:
5506  Exception(char const * in_info) : std::runtime_error(in_info) { }
5507 };
5508 
5509 
5512 {
5513 public:
5514  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5515  Exception(in_info) {}
5516 };
5517 
5518 
5522 {
5523 public:
5524  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5525  Exception(in_info) {}
5526 };
5527 
5528 
5531 {
5532 public:
5533  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5534  Exception(in_info) {}
5535 };
5536 
5537 
5540 {
5541 public:
5542  InvalidLicenseException(char const * in_info) :
5543  Exception(in_info) {}
5544 };
5545 
5546 
5549 {
5550 public:
5551  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5552  Exception(in_info) {}
5553 };
5554 
5556 class IOException : public Exception
5557 {
5558 public:
5562  IOException(char const * in_info, IOResult in_result)
5563  : Exception(in_info), result(in_result) {}
5564 
5565  IOResult result;
5566 };
5567 
5568 
5570 class HPS_API Object
5571 {
5572 public:
5573 
5574  Object();
5575 
5576  virtual ~Object();
5577 
5578  Object & operator=(Object const & other_object);
5579 
5583  Object(Object && in_that);
5584 
5585 
5589  Object & operator=(Object && in_that);
5590 
5594  HPS::Type Type() const;
5595 
5599  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5600 
5603  virtual bool Empty() const {return (impl_ == 0);};
5604 
5606  virtual void Reset();
5607 
5611  bool HasType(HPS::Type in_mask) const;
5612 
5615  intptr_t GetClassID() const;
5616 
5620  intptr_t GetInstanceID() const;
5621 
5622  template <typename T>
5623  static intptr_t ClassID()
5624  {
5625  static const intptr_t ret = T().GetClassID();
5626  return ret;
5627  }
5628 private:
5629 
5630  friend class HPSI::Impl;
5631  friend class HPSI::KeyImpl;
5632  friend class HPSI::TicketImpl;
5633 
5634  HPSI::Impl * impl_;
5635 };
5636 
5637 
5639 class HPS_API Control : public Object
5640 {
5641  HPS::Type ObjectType() const {return HPS::Type::Control;}
5642 
5643 
5644 
5645 protected:
5646  Control() {}
5647 
5651  Control(Control && in_that) : Object(std::move(in_that)) {}
5652 
5656  Control & operator=(Control && in_that)
5657  {
5658  this->Object::operator=(std::move(in_that));
5659  return *this;
5660  }
5661 };
5662 
5663 
5665 class HPS_API ObjectPoint : public Point
5666 {
5667 public:
5668 
5670  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5671 
5673  ObjectPoint(Point const & in_point):Point(in_point){}
5674 
5676  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5677 
5679  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5680 
5682  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5683 
5685  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5686 
5688  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5689 
5691  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5692 
5694  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5695 
5697  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5698 
5700  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5701 
5702 private:
5703 
5704  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5705  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5706  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5707  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5708  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5709  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5710  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5711  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5712 
5713 };
5714 
5716 class HPS_API WorldPoint : public Point
5717 {
5718 public:
5720  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5721 
5723  WorldPoint(Point const & in_point):Point(in_point){}
5724 
5726  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5727 
5729  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5730 
5732  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5733 
5735  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5736 
5738  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5739 
5741  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5742 
5744  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5745 
5747  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5748 
5750  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5751 
5752 private:
5753 
5754  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5755  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5756  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5757  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5758  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5759  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5760  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5761  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5762 
5763 };
5764 
5766 class HPS_API CameraPoint : public Point
5767 {
5768 public:
5770  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5771 
5773  CameraPoint(Point const & in_point):Point(in_point){}
5774 
5776  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5777 
5779  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5780 
5782  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5783 
5785  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5786 
5788  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5789 
5791  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5792 
5794  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5795 
5797  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5798 
5800  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5801 
5802 private:
5803  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5804  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5805  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5806  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5807  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5808  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5809  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5810  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5811 
5812 };
5813 
5815 class HPS_API NormalizedPoint : public Point
5816 {
5817 public:
5818 
5820  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5821 
5823  NormalizedPoint(Point const & in_point):Point(in_point){}
5824 
5826  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5827 
5829  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5830 
5832  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5833 
5835  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5836 
5838  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5839 
5841  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5842 
5844  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5845 
5847  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5848 
5850  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5851 
5852 private:
5853  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5854  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5855  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5856  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5857  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5858  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5859  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5860  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5861 };
5862 
5864 class HPS_API ScreenRangePoint : public Point
5865 {
5866 public:
5868  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5869 
5871  ScreenRangePoint(Point const & in_point):Point(in_point){}
5872 
5874  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5875 
5877  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5878 
5880  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5881 
5883  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5884 
5886  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5887 
5889  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5890 
5892  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5893 
5895  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5896 
5898  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5899 
5900 private:
5901  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5902  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5903  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5904  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5905  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5906  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5907  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5908  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5909 
5910 };
5911 
5913 class HPS_API InnerWindowPoint : public Point
5914 {
5915 public:
5916 
5918  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5919 
5921  InnerWindowPoint(Point const & in_point):Point(in_point){}
5922 
5924  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5925 
5927  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5928 
5930  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5931 
5933  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5934 
5936  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5937 
5939  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5940 
5942  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5943 
5945  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5946 
5948  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5949 
5950 private:
5951  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5952  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5953  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5954  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5955  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5956  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5957  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5958  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5959 };
5960 
5962 class HPS_API InnerPixelPoint : public Point
5963 {
5964 public:
5965 
5967  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5968 
5970  InnerPixelPoint(Point const & in_point):Point(in_point){}
5971 
5973  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5974 
5976  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5977 
5979  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5980 
5982  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5983 
5985  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5986 
5988  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5989 
5991  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5992 
5994  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5995 
5997  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
5998 
5999 private:
6000  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6001  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6002  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6003  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6004  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6005  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6006  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6007  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6008 
6009 };
6010 
6012 class HPS_API WindowPoint : public Point
6013 {
6014 public:
6015 
6017  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6018 
6020  WindowPoint(Point const & in_point):Point(in_point){}
6021 
6023  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6024 
6026  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6027 
6029  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6030 
6032  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6033 
6035  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6036 
6038  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6039 
6041  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6042 
6044  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6045 
6047  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6048 
6049 private:
6050  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6051  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6052  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6053  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6054  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6055  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6056  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6057  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6058 };
6059 
6060 
6062 class HPS_API PixelPoint : public Point
6063 {
6064 public:
6066  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6067 
6069  PixelPoint(Point const & in_point):Point(in_point){}
6070 
6072  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6073 
6075  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6076 
6078  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6079 
6081  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6082 
6084  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6085 
6087  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6088 
6090  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6091 
6093  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6094 
6096  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6097 
6098 private:
6099  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6100  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6101  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6102  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6103  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6104  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6105  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6106  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6107 
6108 };
6109 
6112 class HPS_API Event
6113 {
6114 public:
6118  enum class Status
6119  {
6120  InProgress,
6121  Completed,
6122  Failed
6123  };
6124 
6126  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6127 
6128  virtual ~Event();
6129 
6131  intptr_t GetClassID() const;
6132 
6135  virtual Event * Clone() const=0;
6136 
6138  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6139 
6142  virtual intptr_t Freshen() const { return 0; }
6143 
6145  intptr_t GetChannel() const { return channel; }
6146 
6148  Time GetTimeStamp() const { return time_stamp; }
6149 
6151  bool IsConsumable() const { return consumable; }
6152 
6153  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6154  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6155 
6156 protected:
6157  intptr_t channel;
6158  bool consumable;
6159 
6160 private:
6161  friend class HPSI::EventDispatcherImpl;
6162  Time time_stamp;
6163 };
6164 
6165 
6168 class HPS_API EventNotifier : public Object
6169 {
6170 public:
6171 
6173  EventNotifier();
6174 
6177  EventNotifier(EventNotifier const & in_that);
6178 
6182  EventNotifier(EventNotifier && in_that);
6183 
6187  EventNotifier & operator=(EventNotifier && in_that);
6188 
6189  virtual ~EventNotifier();
6190 
6191  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6192 
6196  EventNotifier & operator=(EventNotifier const & in_that);
6197 
6200  virtual void Assign(EventNotifier const & in_that);
6201 
6203  void Wait() const;
6204 
6207  Event::Status Status() const;
6208 };
6209 
6211 enum class KeyboardCode
6212 {
6213  None = 0,
6214 
6215  Backspace = 8,
6216  Tab = 9,
6217  Clear = 11,
6218  Return = 13,
6219  Shift = 16,
6220  Control = 17,
6221  Alt = 18,
6222  Pause = 19,
6223  Escape = 27,
6224 
6225  Space = 32,
6226  ExclamationMark,
6227  DoubleQuote,
6228  Number,
6229  Dollar,
6230  Percent,
6231  Ampersand,
6232  SingleQuote,
6233  OpenParen,
6234  CloseParen,
6235 
6236  Asterisk,
6237  Plus,
6238  Comma,
6239  Hyphen,
6240  Period,
6241  Slash,
6242 
6243  D0,
6244  D1,
6245  D2,
6246  D3,
6247  D4,
6248  D5,
6249  D6,
6250  D7,
6251  D8,
6252  D9,
6253 
6254  Colon,
6255  Semicolon,
6256  LessThan,
6257  Equal,
6258  GreaterThan,
6259  QuestionMark,
6260  AtSymbol,
6261 
6262  A,
6263  B,
6264  C,
6265  D,
6266  E,
6267  F,
6268  G,
6269  H,
6270  I,
6271  J,
6272  K,
6273  L,
6274  M,
6275  N,
6276  O,
6277  P,
6278  Q,
6279  R,
6280  S,
6281  T,
6282  U,
6283  V,
6284  W,
6285  X,
6286  Y,
6287  Z,
6288 
6289  OpenBrackets,
6290  Backslash,
6291  CloseBrackets,
6292  Caret,
6293  Underscore,
6294  Backtick,
6295 
6296  a,
6297  b,
6298  c,
6299  d,
6300  e,
6301  f,
6302  g,
6303  h,
6304  i,
6305  j,
6306  k,
6307  l,
6308  m,
6309  n,
6310  o,
6311  p,
6312  q,
6313  r,
6314  s,
6315  t,
6316  u,
6317  v,
6318  w,
6319  x,
6320  y,
6321  z,
6322 
6323  OpenBrace,
6324  VerticalBar,
6325  ClosingBrace,
6326  Tilde,
6327  Delete,
6328 
6329  Insert=1024,
6330  Home,
6331  End,
6332  PageUp,
6333  PageDown,
6334 
6335  Help,
6336 
6337  Left,
6338  Up,
6339  Right,
6340  Down,
6341 
6342  NumPad0,
6343  NumPad1,
6344  NumPad2,
6345  NumPad3,
6346  NumPad4,
6347  NumPad5,
6348  NumPad6,
6349  NumPad7,
6350  NumPad8,
6351  NumPad9,
6352 
6353  F1,
6354  F2,
6355  F3,
6356  F4,
6357  F5,
6358  F6,
6359  F7,
6360  F8,
6361  F9,
6362  F10,
6363  F11,
6364  F12,
6365  F13,
6366  F14,
6367  F15,
6368  F16,
6369  F17,
6370  F18,
6371  F19,
6372  F20,
6373  F21,
6374  F22,
6375  F23,
6376  F24,
6377 
6378  // these are not implemented
6379 // CapsLock, //!< The Caps Lock key.
6380 //
6381 // NumLock, //!< The Num Lock key.
6382 // ScrollLock, //!< The Scroll Lock key.
6383 // LeftShift, //!< The left Shift key.
6384 // RightShift, //!< The right Shift key.
6385 // LeftCtrl, //!< The left CTRL key.
6386 // RightCtrl, //!< The right CTRL key.
6387 // LeftAlt, //!< The left ALT key.
6388 // RightAlt, //!< The right ALT key.
6389 //
6390 // Select, //!< The Select key.
6391 // Print, //!< The Print key.
6392 // Execute, //!< The Execute key.
6393 // PrintScreen, //!< The Print Screen key.
6394 };
6395 
6396 
6398 class NO_HPS_API Touch
6399 {
6400 public:
6401 
6404  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6405 
6410  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6411  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6412 
6416  inline bool operator==(Touch const & in_that) const
6417  {
6418  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6419  }
6420 
6424  inline bool operator!=(Touch const & in_that) const
6425  {
6426  return !(*this == in_that);
6427  }
6428 
6429  TouchID ID;
6431  size_t TapCount;
6432 };
6433 
6434 
6435 typedef std::vector<Point, Allocator<Point> > PointArray;
6436 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6437 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6438 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6439 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6440 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6441 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6442 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6443 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6444 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6445 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6446 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6447 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6448 typedef std::vector<int, Allocator<int> > IntArray;
6449 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6450 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6451 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6452 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6453 typedef std::vector<float, Allocator<float> > FloatArray;
6454 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6455 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6456 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6457 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6458 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6459 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6460 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6461 typedef std::vector<bool, Allocator<bool> > BoolArray;
6462 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6463 typedef std::vector<Key, Allocator<Key> > KeyArray;
6464 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6465 typedef std::vector<char, Allocator<char> > CharArray;
6466 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6467 typedef std::vector<byte, Allocator<byte> > ByteArray;
6468 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6469 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6470 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6471 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6472 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6473 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6474 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6475 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6476 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6477 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6478 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6479 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6480 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6481 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6482 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6483 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6484 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6485 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6486 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6487 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6488 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6489 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6490 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6491 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6492 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6493 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6494 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6495 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6496 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6497 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6498 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6499 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6500 
6501 
6503 class HPS_API SearchResultsIterator : public Object
6504 {
6505 public:
6506 
6509 
6513  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6514 
6519 
6523  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6524 
6526 
6527  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6528 
6533  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6534 
6539  void Set(SearchResultsIterator const & in_search_results_iterator);
6540 
6542  void Next();
6543 
6546  SearchResultsIterator & operator++();
6547 
6550  SearchResultsIterator operator++(int in_val);
6551 
6554  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6555 
6558  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6559 
6563  bool IsValid() const;
6564 
6566  void Reset();
6567 
6571  Key GetItem() const;
6572 
6575  Key operator*() const;
6576 
6579  SearchTypeArray GetResultTypes() const;
6580 };
6581 
6583 class HPS_API SearchResults : public Object
6584 {
6585 public:
6587  SearchResults();
6588 
6591  SearchResults(SearchResults const & in_search_results);
6592 
6596  SearchResults(SearchResults && in_that);
6597 
6601  SearchResults & operator=(SearchResults && in_that);
6602 
6604  virtual void Reset();
6605 
6607  ~SearchResults();
6608 
6609  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6610 
6614  void Assign(SearchResults const & in_search_results);
6615 
6619  SearchResults & operator=(SearchResults const & in_search_results);
6620 
6623  size_t GetCount() const;
6624 
6627  SearchResultsIterator GetIterator() const;
6628 };
6629 
6631 class HPS_API FontSearchResultsIterator : public Object
6632 {
6633 public:
6634 
6637 
6641  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6642 
6647 
6652  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6653 
6654 
6658  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6659 
6661 
6662  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6663 
6664 
6669  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6670 
6672  void Next();
6673 
6676  FontSearchResultsIterator & operator++();
6677 
6680  FontSearchResultsIterator operator++(int in_val);
6681 
6684  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6685 
6688  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6689 
6693  bool IsValid() const;
6694 
6696  void Reset();
6697 
6701  FontInfoState GetItem() const;
6702 
6705  FontInfoState operator*() const;
6706 
6707 };
6708 
6710 class HPS_API FontSearchResults : public Object
6711 {
6712 public:
6713 
6716 
6719  FontSearchResults(FontSearchResults const & in_search_results);
6720 
6725 
6729  FontSearchResults & operator=(FontSearchResults && in_that);
6730 
6732  virtual void Reset();
6733 
6735  ~FontSearchResults();
6736 
6737  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
6738 
6742  void Assign(FontSearchResults const & in_search_results);
6743 
6744 
6748  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6749 
6752  size_t GetCount() const;
6753 
6756  FontSearchResultsIterator GetIterator() const;
6757 };
6758 
6760 class HPS_API UTF8
6761 {
6762 public:
6763 
6765  UTF8();
6766 
6768  ~UTF8();
6769 
6776  UTF8(char const * in_string, char const * in_locale = 0);
6777 
6780  UTF8(wchar_t const * in_string);
6781 
6784  UTF8(UTF8 const & in_that);
6785 
6788  UTF8(UTF8 && in_that);
6789 
6793  UTF8 & Assign(UTF8 && in_utf8);
6794 
6797  inline UTF8 & operator= (UTF8 && in_utf8)
6798  {
6799  return Assign(std::move(in_utf8));
6800  }
6801 
6806  size_t ToWStr(wchar_t * out_wide_string) const;
6807 
6811  size_t ToWStr(WCharArray & out_wide_string) const;
6812 
6815  inline bool IsValid() const
6816  {
6817  return (_length > 0);
6818  }
6819 
6822  inline bool Empty() const
6823  {
6824  return (_length == 0);
6825  }
6826 
6828  void Clear();
6829 
6831  void Reset() { Clear(); }
6832 
6836  inline size_t GetLength() const
6837  {
6838  return _length;
6839  }
6840 
6844  inline size_t GetWStrLength() const
6845  {
6846  return ToWStr(0);
6847  }
6848 
6851  inline char const * GetBytes() const
6852  {
6853  return _text;
6854  }
6855 
6858  inline operator char const * () const
6859  {
6860  return _text;
6861  }
6862 
6865  char At(size_t in_index) const
6866  {
6867  if(!IsValid())
6868  throw InvalidObjectException();
6869  else if(in_index >= _length)
6870  throw IndexOutOfRangeException();
6871  else
6872  return _text[in_index];
6873  }
6874 
6878  UTF8 & Assign(UTF8 const & in_utf8);
6879 
6883  inline UTF8 & operator= (UTF8 const & in_utf8)
6884  {
6885  return Assign(in_utf8);
6886  }
6887 
6891  UTF8 & operator+= (UTF8 const & in_utf8);
6892 
6896  UTF8 & operator+= (char const * in_utf8);
6897 
6901  UTF8 operator+ (UTF8 const & in_utf8) const;
6902 
6906  UTF8 operator+ (char const * in_utf8) const;
6907 
6911  bool operator== (UTF8 const & in_utf8) const;
6912 
6916  bool operator!= (UTF8 const & in_utf8) const
6917  {
6918  return !(*this == in_utf8);
6919  }
6920 
6924  bool operator== (char const * in_utf8) const;
6925 
6929  bool operator!= (char const * in_utf8) const
6930  {
6931  return !(*this == in_utf8);
6932  }
6933 
6938  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6939  {
6940  return in_right == in_left;
6941  }
6942 
6947  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
6948  {
6949  return in_right != in_left;
6950  }
6951 
6956  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6957  {
6958  return in_right == UTF8(in_left);
6959  }
6960 
6965  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
6966  {
6967  return in_right != UTF8(in_left);
6968  }
6969 
6974  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
6975  {
6976  return UTF8(in_left) + in_right;
6977  }
6978 
6983  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
6984  {
6985  return UTF8(in_left) + in_right;
6986  }
6987 
6988 
6991  size_t GetHash() const;
6992 
6993 private:
6994 
6995  size_t internal_encode(wchar_t const * in_wide_string);
6996  size_t internal_decode(wchar_t * out_wide_string) const;
6997 
6998  char * _text;
6999  size_t _length;
7000  mutable size_t _hash_key;
7001  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7002  char _buffer[_buffer_size];
7003 };
7004 
7006 struct UTF8Hasher {
7007  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7008  {
7009  return in_utf8.GetHash();
7010  }
7011 };
7012 
7015 class HPS_API Condition : public Object
7016 {
7017 public:
7018 
7019  enum class Intrinsic
7020  {
7021  Extent,
7022  DrawPass
7023  };
7024 
7026  Condition();
7027 
7030  Condition(char const * in_utf8);
7031 
7034  Condition(float in_number);
7035 
7038  Condition(HPS::Condition::Intrinsic in_special);
7039 
7042  Condition(Condition const & in_that);
7043 
7047  Condition(Condition && in_that);
7048 
7052  Condition & operator=(Condition && in_that);
7053 
7054  HPS::Type ObjectType() const { return HPS::Type::Condition; }
7055 
7059  bool ShowCondition(UTF8 & out_condition) const;
7060 
7064  bool ShowNumber(float & out_number) const;
7065 
7069  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7070 
7074  bool ShowOperands(ConditionArray & out_operands) const;
7075 
7079  Condition & operator=(Condition const & in_that);
7080 
7084  bool Equals(Condition const & in_that) const;
7085 
7089  bool operator==(Condition const & in_that) const;
7090 
7094  bool operator!=(Condition const & in_that) const;
7095 
7099  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7100 
7104  bool IsSatisfiedBy(char const * in_condition) const;
7105 
7109  Condition OR(Condition const & in_operand2) const;
7110 
7114  Condition XOR(Condition const & in_operand2) const;
7115 
7119  Condition AND(Condition const & in_operand2) const;
7120 
7124  Condition EQ(Condition const & in_operand2) const;
7125 
7129  Condition NEQ(Condition const & in_operand2) const;
7130 
7134  Condition GT(Condition const & in_operand2) const;
7135 
7139  Condition LT(Condition const & in_operand2) const;
7140 
7144  Condition GTEQ(Condition const & in_operand2) const;
7145 
7149  Condition LTEQ(Condition const & in_operand2) const;
7150 
7153  Condition operator !() const;
7154 
7158  Condition operator ||(Condition const & in_operand2) const;
7159 
7163  Condition operator ^(Condition const & in_operand2) const;
7164 
7168  Condition operator &&(Condition const & in_operand2) const;
7169 
7170 
7174  static Condition NOT(Condition const & in_operand);
7175 
7180  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7181 
7182 
7187  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7188 
7193  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7194 
7199  static Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7200 
7205  static Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7206 
7211  static Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7212 
7217  static Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7218 
7223  static Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7224 
7229  static Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7230 
7231  friend HPS_API Condition NOT(Condition const & in_operand);
7232  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7233  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7234  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7235 
7236  friend HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7237  friend HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7238  friend HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7239  friend HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7240  friend HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7241  friend HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7242 };
7243 
7244 
7248 HPS_API Condition NOT(Condition const & in_operand);
7249 
7254 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7255 
7260 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7261 
7266 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7267 
7272 HPS_API Condition EQ(Condition const & in_operand1, Condition const & in_operand2);
7273 
7278 HPS_API Condition NEQ(Condition const & in_operand1, Condition const & in_operand2);
7279 
7284 HPS_API Condition GT(Condition const & in_operand1, Condition const & in_operand2);
7285 
7290 HPS_API Condition LT(Condition const & in_operand1, Condition const & in_operand2);
7291 
7296 HPS_API Condition GTEQ(Condition const & in_operand1, Condition const & in_operand2);
7297 
7302 HPS_API Condition LTEQ(Condition const & in_operand1, Condition const & in_operand2);
7303 
7304 
7305 
7309 class HPS_API Key : public Object
7310 {
7311 public:
7312 
7314  Key();
7315 
7317  Key(Key const & in_that);
7318 
7320  explicit Key(Control const & in_control);
7321 
7325  Key(Key && in_that);
7326 
7330  Key & operator=(Key && in_that);
7331 
7333  virtual ~Key();
7334 
7335  HPS::Type ObjectType() const {return HPS::Type::Key;};
7336 
7338  bool HasOwner() const;
7339 
7341  SegmentKey Up() const;
7342 
7344  SegmentKey Owner() const;
7345 
7347  void Delete();
7348 
7350  void MoveTo(SegmentKey const & in_new_owner);
7351 
7354  Key CopyTo(SegmentKey const & in_destination) const;
7355 
7357  Key & operator=(Key const & in_that);
7358 
7360  virtual void Assign(Key const & in_that);
7361 
7363  bool Equals(Key const & in_that) const;
7364 
7366  bool operator!= (Key const & in_that) const;
7367 
7369  bool operator== (Key const & in_that) const;
7370 
7373  size_t GetHash() const;
7374 };
7375 
7377 struct KeyHasher {
7378  inline size_t operator()(const HPS::Key & in_key) const
7379  {
7380  return in_key.GetHash();
7381  }
7382 };
7383 
7384 
7387 class HPS_API SegmentKey : public Key
7388 {
7389 public:
7391  SegmentKey();
7392 
7394  SegmentKey(SegmentKey const & in_that);
7395 
7397  SegmentKey & operator=(SegmentKey const & other);
7398 
7402  SegmentKey(SegmentKey && in_that);
7403 
7407  SegmentKey & operator=(SegmentKey && in_that);
7408 
7410  explicit SegmentKey(Key const & in_that);
7411 
7413  ~SegmentKey();
7414 
7415  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7416 
7418  UTF8 Name() const;
7419 
7422  SegmentKey & SetName(char const * in_name);
7423 
7426  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7427 
7430  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7431 
7433  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7434 
7436  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7437 
7439  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7440 
7441 
7442 
7444  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7445 
7447  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7448 
7450  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7451 
7452 
7454  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7455 
7457  size_t Find(SearchOptionsKit const & in_options) const;
7458 
7459 
7462  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7463 
7467  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7468 
7469 
7475  ReferenceKey ReferenceGeometry(Key const & in_key);
7476 
7484  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7485 
7486 
7488  size_t ShowSubsegments() const;
7489 
7491  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7492 
7496  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7497 
7501  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7502 
7506  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7507 
7511  size_t ShowStylers(StyleKeyArray & out_styles) const;
7512 
7516  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7517 
7521  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7522 
7523 
7524 
7526  StyleControl GetStyleControl();
7527 
7529  StyleControl const GetStyleControl() const;
7530 
7531 
7533  PortfolioControl GetPortfolioControl();
7534 
7536  PortfolioControl const GetPortfolioControl() const;
7537 
7538 
7540  SegmentKey & SetCondition(char const * in_condition);
7541 
7543  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7544 
7546  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7547 
7549  SegmentKey & UnsetConditions();
7550 
7552  bool ShowConditions(UTF8Array & out_conditions) const;
7553 
7555  ConditionControl GetConditionControl();
7556 
7558  ConditionControl const GetConditionControl() const;
7559 
7560 
7562  SegmentKey & SetMaterialPalette(char const * in_name);
7563 
7565  SegmentKey & UnsetMaterialPalette();
7566 
7568  bool ShowMaterialPalette(UTF8 & out_name) const;
7569 
7570 
7577  SegmentKey & SetPriority(int in_priority);
7578 
7581  SegmentKey & UnsetPriority();
7582 
7586  bool ShowPriority(int & out_priority) const;
7587 
7592  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7593 
7599  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7600 
7605  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7606 
7610  SegmentKey & UnsetUserData(intptr_t in_index);
7611 
7616  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7617 
7621  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7622 
7625  SegmentKey & UnsetAllUserData();
7626 
7628  size_t ShowUserDataCount() const;
7629 
7634  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7635 
7639  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7640 
7645  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7646 
7647 
7649  LineKey InsertLine(LineKit const & in_kit);
7650 
7652  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7653 
7655  LineKey InsertLine(PointArray const & in_pts);
7656 
7658  LineKey InsertLine(Point const & pt1, Point const & pt2);
7659 
7660 
7662  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7663 
7665  CylinderKey InsertCylinder(size_t in_pcount, Point const in_points[], size_t in_rcount, float const in_radii [], Cylinder::Capping in_caps = Cylinder::Capping::Both);
7666 
7668  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7669 
7671  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7672 
7673 
7678  SphereKey InsertSphere(SphereKit const & in_kit);
7679 
7687  SphereKey InsertSphere(Point const & in_center, float in_radius, Vector const & in_axis = Vector(0, 1, 0), Vector const & in_prime_meridian = Vector(1, 0, 0));
7688 
7690  CircleKey InsertCircle(CircleKit const & in_kit);
7691 
7693  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7694 
7696  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7697 
7698 
7700  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7701 
7703  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7704 
7705 
7707  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7708 
7710  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7711 
7712 
7714  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7715 
7717  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7718 
7719 
7721  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7722 
7724  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float start, float end);
7725 
7726 
7728  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7729 
7731  PolygonKey InsertPolygon(PointArray const & in_pts);
7732 
7734  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7735 
7736 
7738  ShellKey InsertShell(ShellKit const & in_kit);
7739 
7741  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7742 
7744  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7745 
7747  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
7748 
7750  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
7751 
7753  MeshKey InsertMesh(MeshKit const & in_kit);
7754 
7756  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7757 
7759  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7760 
7761 
7763  MarkerKey InsertMarker(Point const & in_position);
7764 
7766  MarkerKey InsertMarker(MarkerKit const & in_kit);
7767 
7768 
7770  DistantLightKey InsertDistantLight(Vector const & in_direction);
7771 
7773  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7774 
7775 
7777  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7778 
7780  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7781 
7783  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7784 
7786  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7787 
7788 
7790  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7791 
7793  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7794 
7795 
7797  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7798 
7800  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7801 
7802 
7804  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7805 
7807  NURBSCurveKey InsertNURBSCurve(size_t in_degree, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_knots, float in_start_u, float in_end_u);
7808 
7810  NURBSCurveKey InsertNURBSCurve(size_t in_degree, size_t in_pcount, Point const in_points [], float const in_weights[], size_t in_knot_count, float const in_knots[], float in_start_u, float in_end_u);
7811 
7812 
7814  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7815 
7817  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_uknots, FloatArray const & in_vknots);
7818 
7820  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, size_t in_point_count, Point const in_points[], float const in_weights[], size_t in_uknot_count, float const in_uknots[], size_t in_vknot_count, float const in_vknots[]);
7821 
7823  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_uknots, FloatArray const & in_vknots, TrimKitArray const & in_trims);
7824 
7826  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, size_t in_point_count, Point const in_points[], float const in_weights[], size_t in_uknot_count, float const in_uknots[], size_t in_vknot_count, float const in_vknots[], size_t in_trim_count, TrimKit const in_trims[]);
7827 
7828 
7830  TextKey InsertText(TextKit const & in_kit);
7831 
7837  TextKey InsertText(Point const & in_position, char const * in_text);
7838 
7839 
7840 
7842  GridKey InsertGrid(GridKit const & in_kit);
7843 
7845  GridKey InsertGrid(Point const & in_origin, Point const & in_first_point = Point(1, 0, 0), Point const & in_second_point = Point(0, 1, 0), int in_first_count = 0, int in_second_count = 0, Grid::Type in_type = Grid::Type::Quadrilateral);
7846 
7847 
7848 
7856  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7857 
7865  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7866 
7874  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7875 
7883  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7884 
7892  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7893 
7901  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7902 
7907  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7908 
7913  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7914 
7919  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7920 
7925  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7926 
7931  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7932 
7937  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7938 
7939 
7941  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7942 
7944  SegmentKey & UnsetAttributeLocks();
7945 
7949  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7950 
7952  AttributeLockControl GetAttributeLockControl();
7953 
7955  AttributeLockControl const GetAttributeLockControl() const;
7956 
7957 
7959  SegmentKey & SetBoundings(BoundingKit const & in_kit);
7960 
7962  SegmentKey & UnsetBoundings();
7963 
7967  bool ShowBoundings(BoundingKit & out_kit) const;
7968 
7970  BoundingControl GetBoundingControl();
7971 
7973  BoundingControl const GetBoundingControl() const;
7974 
7975 
7977  SegmentKey & SetCamera(CameraKit const & in_kit);
7978 
7980  SegmentKey & UnsetCamera();
7981 
7983  bool ShowCamera(CameraKit & out_kit) const;
7984 
7986  CameraControl GetCameraControl();
7987 
7989  CameraControl const GetCameraControl() const;
7990 
7992  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
7993 
7995  SegmentKey & UnsetColorInterpolation();
7996 
7998  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
7999 
8001  ColorInterpolationControl GetColorInterpolationControl();
8002 
8004  ColorInterpolationControl const GetColorInterpolationControl() const;
8005 
8006 
8008  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8009 
8011  SegmentKey & UnsetContourLine();
8012 
8014  bool ShowContourLine(ContourLineKit & out_kit) const;
8015 
8017  ContourLineControl GetContourLineControl();
8018 
8020  ContourLineControl const GetContourLineControl() const;
8021 
8022 
8024  SegmentKey & SetCulling(CullingKit const & in_kit);
8025 
8027  SegmentKey & UnsetCulling();
8028 
8032  bool ShowCulling(CullingKit & out_kit) const;
8033 
8035  CullingControl GetCullingControl();
8036 
8038  CullingControl const GetCullingControl() const;
8039 
8040 
8042  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
8043 
8045  SegmentKey & UnsetCurveAttributes();
8046 
8048  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
8049 
8051  CurveAttributeControl GetCurveAttributeControl();
8052 
8054  CurveAttributeControl const GetCurveAttributeControl() const;
8055 
8056 
8058  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
8059 
8061  SegmentKey & UnsetCuttingSectionAttributes();
8062 
8064  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8065 
8067  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8068 
8070  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8071 
8072 
8074  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
8075 
8077  SegmentKey & UnsetCylinderAttributes();
8078 
8080  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
8081 
8083  CylinderAttributeControl GetCylinderAttributeControl();
8084 
8086  CylinderAttributeControl const GetCylinderAttributeControl() const;
8087 
8088 
8090  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8091 
8093  SegmentKey & UnsetDrawingAttribute();
8094 
8096  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8097 
8099  DrawingAttributeControl GetDrawingAttributeControl();
8100 
8102  DrawingAttributeControl const GetDrawingAttributeControl() const;
8103 
8104 
8106  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
8107 
8109  SegmentKey & UnsetEdgeAttributes();
8110 
8112  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
8113 
8115  EdgeAttributeControl GetEdgeAttributeControl();
8116 
8118  EdgeAttributeControl const GetEdgeAttributeControl() const;
8119 
8120 
8122  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8123 
8125  SegmentKey & UnsetHiddenLineAttribute();
8126 
8128  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8129 
8131  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8132 
8134  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8135 
8136 
8138  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
8139 
8141  SegmentKey & UnsetLightingAttributes();
8142 
8144  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
8145 
8147  LightingAttributeControl GetLightingAttributeControl();
8148 
8150  LightingAttributeControl const GetLightingAttributeControl() const;
8151 
8152 
8154  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
8155 
8157  SegmentKey & UnsetLineAttributes();
8158 
8160  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
8161 
8163  LineAttributeControl GetLineAttributeControl();
8164 
8166  LineAttributeControl const GetLineAttributeControl() const;
8167 
8168 
8170  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8171 
8173  SegmentKey & UnsetMaterialMapping();
8174 
8176  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8177 
8179  MaterialMappingControl GetMaterialMappingControl();
8180 
8182  MaterialMappingControl const GetMaterialMappingControl() const;
8183 
8184 
8186  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
8187 
8189  SegmentKey & UnsetMarkerAttributes();
8190 
8192  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
8193 
8195  MarkerAttributeControl GetMarkerAttributeControl();
8196 
8198  MarkerAttributeControl const GetMarkerAttributeControl() const;
8199 
8200 
8202  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8203 
8205  SegmentKey & UnsetModellingMatrix();
8206 
8208  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8209 
8211  ModellingMatrixControl GetModellingMatrixControl();
8212 
8214  ModellingMatrixControl const GetModellingMatrixControl() const;
8215 
8216 
8218  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
8219 
8221  SegmentKey & UnsetNURBSSurfaceAttributes();
8222 
8224  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8225 
8227  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8228 
8230  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8231 
8232 
8234  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8235 
8237  SegmentKey & UnsetPerformance();
8238 
8240  bool ShowPerformance(PerformanceKit & out_kit) const;
8241 
8243  PerformanceControl GetPerformanceControl();
8244 
8246  PerformanceControl const GetPerformanceControl() const;
8247 
8248 
8250  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8251 
8253  SegmentKey & UnsetSelectability();
8254 
8258  bool ShowSelectability(SelectabilityKit & out_kit) const;
8259 
8261  SelectabilityControl GetSelectabilityControl();
8262 
8264  SelectabilityControl const GetSelectabilityControl() const;
8265 
8266 
8268  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8269 
8271  SegmentKey & UnsetSphereAttributes();
8272 
8276  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8277 
8279  SphereAttributeControl GetSphereAttributeControl();
8280 
8282  SphereAttributeControl const GetSphereAttributeControl() const;
8283 
8284 
8286  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8287 
8289  SegmentKey & UnsetSubwindow();
8290 
8294  bool ShowSubwindow(SubwindowKit & out_kit) const;
8295 
8297  SubwindowControl GetSubwindowControl();
8298 
8300  SubwindowControl const GetSubwindowControl() const;
8301 
8302 
8304  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8305 
8307  SegmentKey & UnsetTextAttributes();
8308 
8310  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8311 
8313  TextAttributeControl GetTextAttributeControl();
8314 
8316  TextAttributeControl const GetTextAttributeControl() const;
8317 
8318 
8320  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8321 
8323  SegmentKey & UnsetTextureMatrix();
8324 
8328  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8329 
8331  TextureMatrixControl GetTextureMatrixControl();
8332 
8334  TextureMatrixControl const GetTextureMatrixControl() const;
8335 
8337  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8338 
8340  SegmentKey & UnsetTransformMask();
8341 
8345  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8346 
8348  TransformMaskControl GetTransformMaskControl();
8349 
8351  TransformMaskControl const GetTransformMaskControl() const;
8352 
8353 
8355  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8356 
8358  SegmentKey & UnsetTransparency();
8359 
8363  bool ShowTransparency(TransparencyKit & out_kit) const;
8364 
8366  TransparencyControl GetTransparencyControl();
8367 
8369  TransparencyControl const GetTransparencyControl() const;
8370 
8371 
8373  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8374 
8376  SegmentKey & UnsetVisibility();
8377 
8381  bool ShowVisibility(VisibilityKit & out_kit) const;
8382 
8384  VisibilityControl GetVisibilityControl();
8385 
8387  VisibilityControl const GetVisibilityControl() const;
8388 
8389 
8391  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8392 
8394  SegmentKey & UnsetVisualEffects();
8395 
8399  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8400 
8402  VisualEffectsControl GetVisualEffectsControl();
8403 
8405  VisualEffectsControl const GetVisualEffectsControl() const;
8406 
8407  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8408 };
8409 
8410 
8413 {
8414 public:
8415 
8418 
8422 
8426 
8427  virtual ~SegmentOptimizationOptionsKit();
8428 
8429  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8430 
8433  void Consume(SegmentOptimizationOptionsKit & in_kit);
8434 
8437  void Set(SegmentOptimizationOptionsKit const & in_kit);
8438 
8441  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8442 
8447 
8452 
8455  bool Empty() const;
8456 
8460  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8461 
8465  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8466 
8470  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8471 
8475  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8476 
8480  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8481 
8485  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8486 
8490  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8491 
8495  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8496 
8500  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8501 
8505  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8506 
8510  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8511 
8513  SegmentOptimizationOptionsKit & UnsetUserData();
8514 
8516  SegmentOptimizationOptionsKit & UnsetMatrix();
8517 
8519  SegmentOptimizationOptionsKit & UnsetExpansion();
8520 
8522  SegmentOptimizationOptionsKit & UnsetScope();
8523 
8525  SegmentOptimizationOptionsKit & UnsetReorganization();
8526 
8528  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8529 
8531  SegmentOptimizationOptionsKit & UnsetShellMerging();
8532 
8534  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8535 
8538  SegmentOptimizationOptionsKit & UnsetEverything();
8539 
8540  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8541 
8542  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8543 
8544  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8545 
8546  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8547 
8548  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8549 
8550  bool ShowShellInstancing(bool & out_shell_instancing) const;
8551 
8552  bool ShowShellMerging(bool & out_shell_merging) const;
8553 
8554  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8555 };
8556 
8557 
8559 class HPS_API Coordinate
8560 {
8561 public:
8562 
8566  enum class Space
8567  {
8568  Object,
8569  World,
8570  Camera,
8571  Normalized,
8572  ScreenRange,
8573  InnerWindow,
8574  InnerPixel,
8575  Window,
8576  Pixel,
8577  };
8578 
8579 private:
8580  Coordinate();
8581 };
8582 
8583 
8584 
8585 
8588 class HPS_API UpdateNotifier : public Object
8589 {
8590 public:
8591 
8592  UpdateNotifier();
8593 
8594  UpdateNotifier(UpdateNotifier const & in_that);
8595 
8599  UpdateNotifier(UpdateNotifier && in_that);
8600 
8604  UpdateNotifier & operator=(UpdateNotifier && in_that);
8605 
8606  virtual ~UpdateNotifier();
8607 
8608  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8609 
8611  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8612 
8614  void Assign(UpdateNotifier const & in_that);
8615 
8616  void Wait() const;
8617 
8618  Window::UpdateStatus Status() const;
8619 
8620 };
8621 
8622 
8626 class HPS_API WindowKey : public SegmentKey
8627 {
8628 public:
8629 
8631  WindowKey();
8632 
8634  WindowKey(WindowKey const & in_window);
8635 
8637  WindowKey & operator=(WindowKey const & other);
8638 
8642  WindowKey(WindowKey && in_that);
8643 
8647  WindowKey & operator=(WindowKey && in_that);
8648 
8650  WindowKey(Key const & in_key);
8651 
8653  ~WindowKey();
8654 
8655  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
8656 
8658  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8659 
8661  size_t FindFonts(FontSearchResults & out_results) const;
8662 
8664  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8665 
8667  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8668 
8670  PostProcessEffectsControl GetPostProcessEffectsControl();
8671 
8673  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8674 
8675 
8677  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8678 
8682  bool ShowDebugging(DebuggingKit & out_kit) const;
8683 
8685  DebuggingControl GetDebuggingControl();
8686 
8688  DebuggingControl const GetDebuggingControl() const;
8689 
8691  WindowInfoControl const GetWindowInfoControl() const;
8692 
8693  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8694 
8696  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8697 
8699  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8700 
8702  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
8703 
8705  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
8706 
8707 
8709  SelectionOptionsControl GetSelectionOptionsControl();
8710 
8712  SelectionOptionsControl const GetSelectionOptionsControl() const;
8713 
8714 
8716  SelectionControl GetSelectionControl();
8717 
8719  SelectionControl const GetSelectionControl() const;
8720 
8722  HighlightControl GetHighlightControl();
8723 
8725  HighlightControl const GetHighlightControl() const;
8726 
8728  UpdateOptionsControl GetUpdateOptionsControl();
8729 
8731  UpdateOptionsControl const GetUpdateOptionsControl() const;
8732 
8734  void Update();
8735 
8740  void Update(UpdateOptionsKit const & in_kit);
8741 
8756  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8757 
8761  UpdateNotifier UpdateWithNotifier();
8762 
8766  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
8767 
8773  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8774 
8776  EventDispatcher & GetEventDispatcher();
8777 
8779  EventDispatcher const & GetEventDispatcher() const;
8780 
8784  bool ShowSnapshot(ImageKit & out_kit) const;
8785 
8786 private:
8787 
8789  SegmentKey & UnsetAttributeLocks();
8790  SegmentKey & UnsetCamera();
8791  SegmentKey & UnsetColorInterpolation();
8792  SegmentKey & UnsetContourLine();
8793  SegmentKey & UnsetCulling();
8794  SegmentKey & UnsetCurveAttributes();
8795  SegmentKey & UnsetCuttingSectionAttributes();
8796  SegmentKey & UnsetCylinderAttributes();
8797  SegmentKey & UnsetDrawingAttribute();
8798  SegmentKey & UnsetEdgeAttributes();
8799  SegmentKey & UnsetHiddenLineAttribute();
8800  SegmentKey & UnsetLightingAttributes();
8801  SegmentKey & UnsetLineAttributes();
8802  SegmentKey & UnsetMaterialMapping();
8803  SegmentKey & UnsetMarkerAttributes();
8804  SegmentKey & UnsetModellingMatrix();
8805  SegmentKey & UnsetNURBSSurfaceAttributes();
8806  SegmentKey & UnsetPerformance();
8807  SegmentKey & UnsetSelectability();
8808  SegmentKey & UnsetSphereAttributes();
8809  SegmentKey & UnsetSubwindow();
8810  SegmentKey & UnsetTextAttributes();
8811  SegmentKey & UnsetTextureMatrix();
8812  SegmentKey & UnsetTransformMask();
8813  SegmentKey & UnsetTransparency();
8814  SegmentKey & UnsetVisibility();
8815  SegmentKey & UnsetVisualEffects();
8816 
8818  void MoveTo(SegmentKey const & in_new_owner);
8819 
8821  Key CopyTo(SegmentKey const & in_destination) const;
8822 };
8823 
8824 
8825 
8828 class HPS_API KeyPath : public Object
8829 {
8830 public:
8831 
8833  KeyPath();
8834 
8837  KeyPath(KeyArray const & in_path);
8838 
8842  KeyPath(size_t in_path_count, Key const in_path []);
8843 
8845  KeyPath(KeyPath const & in_that);
8846 
8850  KeyPath(KeyPath && in_that);
8851 
8855  KeyPath & operator=(KeyPath && in_that);
8856 
8858  virtual ~KeyPath();
8859 
8860  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
8861 
8865  KeyPath & operator+=(Key const & in_key);
8866 
8870  KeyPath & operator+=(KeyPath const & in_key_path);
8871 
8875  KeyPath & operator+=(KeyArray const & in_key_array);
8876 
8880  KeyPath & Append(Key const & in_key);
8881 
8885  KeyPath & Append(KeyPath const & in_key_path);
8886 
8890  KeyPath & Append(KeyArray const & in_key_array);
8891 
8895  KeyPath & operator=(KeyPath const & in_that);
8896 
8900  KeyPath & operator=(KeyArray const & in_path);
8901 
8904  void Set(KeyPath const & in_that);
8905 
8909  bool Equals(KeyPath const & in_that) const;
8910 
8914  bool operator!= (KeyPath const & in_that) const;
8915 
8919  bool operator== (KeyPath const & in_that) const;
8920 
8921 
8925  KeyPath & SetKeys(KeyArray const & in_keys);
8926 
8931  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
8932 
8933 
8936  KeyPath & UnsetKeys();
8937 
8938 
8941  bool ShowKeys(KeyArray & out_keys) const;
8942 
8943 
8950  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8951 
8958  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
8959 
8965  bool ComputeTextExtent(const char* in_text, float & out_xfrac, float & out_yfrac) const;
8966 
8967 
8973  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
8974 
8975 
8978  bool ShowNetVisibility(VisibilityKit & out_kit) const;
8979 
8982  bool ShowNetBounding(BoundingKit & out_kit) const;
8983 
8986  bool ShowNetCamera(CameraKit & out_kit) const;
8987 
8990  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
8991 
8994  bool ShowNetContourLine(ContourLineKit & out_kit) const;
8995 
8998  bool ShowNetPerformance(PerformanceKit & out_kit) const;
8999 
9002  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9003 
9006  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9007 
9010  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9011 
9014  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
9015 
9018  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
9019 
9022  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
9023 
9026  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
9027 
9030  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
9031 
9034  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
9035 
9038  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
9039 
9042  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
9043 
9046  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
9047 
9050  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9051 
9054  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9055 
9058  bool ShowNetCulling(CullingKit & out_kit) const;
9059 
9062  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9063 
9066  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9067 
9070  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9071 
9074  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
9075 
9078  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9079 
9082  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9083 
9086  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
9087 
9090  bool ShowNetConditions(UTF8Array & out_conditions) const;
9091 
9097  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9098 
9099 };
9100 
9101 
9106 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9107 {
9108  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9109 }
9110 
9115 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9116 {
9117  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9118 }
9119 
9124 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9125 {
9126  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9127 }
9128 
9133 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9134 {
9135  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9136 }
9137 
9142 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9143 {
9144  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9145 }
9146 
9151 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9152 {
9153  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9154 }
9155 
9160 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9161 {
9162  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9163 }
9164 
9169 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9170 {
9171  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9172 }
9173 
9178 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9179 {
9180  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9181 }
9182 
9183 
9187 
9189 class HPS_API BoundingKit : public Object
9190 {
9191 public:
9192 
9194  BoundingKit();
9195 
9198  BoundingKit(BoundingKit const & in_kit);
9199 
9203  BoundingKit(BoundingKit && in_that);
9204 
9208  BoundingKit & operator=(BoundingKit && in_that);
9209 
9211  virtual ~BoundingKit();
9212 
9213  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9214 
9218  static BoundingKit GetDefault();
9219 
9222  void Set(BoundingKit const & in_kit);
9223 
9226  void Show(BoundingKit & out_kit) const;
9227 
9231  BoundingKit & operator=(BoundingKit const & in_kit);
9232 
9235  bool Empty() const;
9236 
9240  bool Equals(BoundingKit const & in_kit) const;
9241 
9245  bool operator==(BoundingKit const & in_kit) const;
9246 
9250  bool operator!=(BoundingKit const & in_kit) const;
9251 
9252 
9256  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9257 
9261  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9262 
9266  BoundingKit & SetExclusion(bool in_exclude);
9267 
9268 
9271  BoundingKit & UnsetVolume();
9272 
9275  BoundingKit & UnsetExclusion();
9276 
9279  BoundingKit & UnsetEverything();
9280 
9281 
9286  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9287 
9291  bool ShowExclusion(bool & out_exclusion) const;
9292 
9293 };
9294 
9295 
9298 class HPS_API BoundingControl : public Control
9299 {
9300 public:
9301 
9303  explicit BoundingControl(SegmentKey & in_seg);
9304 
9306  BoundingControl(BoundingControl const & in_that);
9307 
9311  BoundingControl(BoundingControl && in_that);
9312 
9316  BoundingControl & operator=(BoundingControl && in_that);
9317 
9319  ~BoundingControl();
9320 
9321  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9322 
9324  BoundingControl & operator=(BoundingControl const & in_that);
9325 
9330  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9331 
9335  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9336 
9340  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9341 
9345  BoundingControl & SetExclusion(bool in_exclusion);
9346 
9347 
9350  BoundingControl & UnsetVolume();
9351 
9354  BoundingControl & UnsetExclusion();
9355 
9358  BoundingControl & UnsetEverything();
9359 
9360 
9365  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9366 
9370  bool ShowExclusion(bool & out_exclusion) const;
9371 
9372 private:
9374  BoundingControl();
9375 };
9376 
9377 
9379 class HPS_API VisibilityKit : public Object
9380 {
9381 public:
9382 
9384  VisibilityKit();
9385 
9388  VisibilityKit(VisibilityKit const & in_kit);
9389 
9393  VisibilityKit(VisibilityKit && in_that);
9394 
9398  VisibilityKit & operator=(VisibilityKit && in_that);
9399 
9401  virtual ~VisibilityKit();
9402 
9403  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9404 
9408  static VisibilityKit GetDefault();
9409 
9412  void Set(VisibilityKit const & in_kit);
9413 
9416  void Show(VisibilityKit & out_kit) const;
9417 
9421  VisibilityKit & operator=(VisibilityKit const & in_kit);
9422 
9425  bool Empty() const;
9426 
9430  bool Equals(VisibilityKit const & in_kit) const;
9431 
9435  bool operator==(VisibilityKit const & in_kit) const;
9436 
9440  bool operator!=(VisibilityKit const & in_kit) const;
9441 
9442 
9446  VisibilityKit & SetCuttingSections(bool in_state);
9447 
9451  VisibilityKit & SetCutEdges(bool in_state);
9452 
9456  VisibilityKit & SetCutFaces(bool in_state);
9457 
9461  VisibilityKit & SetWindows(bool in_state);
9462 
9466  VisibilityKit & SetText(bool in_state);
9467 
9471  VisibilityKit & SetLines(bool in_state);
9472 
9476  VisibilityKit & SetEdgeLights(bool in_state);
9477 
9481  VisibilityKit & SetMarkerLights(bool in_state);
9482 
9486  VisibilityKit & SetFaceLights(bool in_state);
9487 
9491  VisibilityKit & SetGenericEdges(bool in_state);
9492 
9496  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9497 
9504  VisibilityKit & SetAdjacentEdges(bool in_state);
9505 
9509  VisibilityKit & SetHardEdges(bool in_state);
9510 
9514  VisibilityKit & SetMeshQuadEdges(bool in_state);
9515 
9519  VisibilityKit & SetNonCulledEdges(bool in_state);
9520 
9524  VisibilityKit & SetPerimeterEdges(bool in_state);
9525 
9529  VisibilityKit & SetFaces(bool in_state);
9530 
9534  VisibilityKit & SetVertices(bool in_state);
9535 
9539  VisibilityKit & SetMarkers(bool in_state);
9540 
9544  VisibilityKit & SetShadowCasting(bool in_state);
9545 
9549  VisibilityKit & SetShadowReceiving(bool in_state);
9550 
9554  VisibilityKit & SetShadowEmitting(bool in_state);
9555 
9556 
9560  VisibilityKit & SetCutGeometry(bool in_state);
9561 
9565  VisibilityKit & SetEdges(bool in_state);
9566 
9570  VisibilityKit & SetGeometry(bool in_state);
9571 
9575  VisibilityKit & SetLights(bool in_state);
9576 
9580  VisibilityKit & SetShadows(bool in_state);
9581 
9585  VisibilityKit & SetEverything(bool in_state);
9586 
9587 
9590  VisibilityKit & UnsetCuttingSections();
9591 
9594  VisibilityKit & UnsetCutEdges();
9595 
9598  VisibilityKit & UnsetCutFaces();
9599 
9602  VisibilityKit & UnsetWindows();
9603 
9606  VisibilityKit & UnsetText();
9607 
9610  VisibilityKit & UnsetLines();
9611 
9614  VisibilityKit & UnsetEdgeLights();
9615 
9618  VisibilityKit & UnsetMarkerLights();
9619 
9622  VisibilityKit & UnsetFaceLights();
9623 
9626  VisibilityKit & UnsetGenericEdges();
9627 
9630  VisibilityKit & UnsetInteriorSilhouetteEdges();
9631 
9634  VisibilityKit & UnsetAdjacentEdges();
9635 
9638  VisibilityKit & UnsetHardEdges();
9639 
9642  VisibilityKit & UnsetMeshQuadEdges();
9643 
9646  VisibilityKit & UnsetNonCulledEdges();
9647 
9650  VisibilityKit & UnsetPerimeterEdges();
9651 
9654  VisibilityKit & UnsetFaces();
9655 
9658  VisibilityKit & UnsetVertices();
9659 
9662  VisibilityKit & UnsetMarkers();
9663 
9666  VisibilityKit & UnsetShadowCasting();
9667 
9670  VisibilityKit & UnsetShadowReceiving();
9671 
9674  VisibilityKit & UnsetShadowEmitting();
9675 
9676 
9679  VisibilityKit & UnsetCutGeometry();
9680 
9683  VisibilityKit & UnsetEdges();
9684 
9687  VisibilityKit & UnsetGeometry();
9688 
9691  VisibilityKit & UnsetLights();
9692 
9695  VisibilityKit & UnsetShadows();
9696 
9699  VisibilityKit & UnsetEverything();
9700 
9701 
9705  bool ShowCuttingSections(bool & out_state) const;
9706 
9710  bool ShowCutEdges(bool & out_state) const;
9711 
9715  bool ShowCutFaces(bool & out_state) const;
9716 
9720  bool ShowWindows(bool & out_state) const;
9721 
9725  bool ShowText(bool & out_state) const;
9726 
9730  bool ShowLines(bool & out_state) const;
9731 
9735  bool ShowEdgeLights(bool & out_state) const;
9736 
9740  bool ShowMarkerLights(bool & out_state) const;
9741 
9745  bool ShowFaceLights(bool & out_state) const;
9746 
9750  bool ShowGenericEdges(bool & out_state) const;
9751 
9755  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9756 
9760  bool ShowAdjacentEdges(bool & out_state) const;
9761 
9765  bool ShowHardEdges(bool & out_state) const;
9766 
9770  bool ShowMeshQuadEdges(bool & out_state) const;
9771 
9775  bool ShowNonCulledEdges(bool & out_state) const;
9776 
9780  bool ShowPerimeterEdges(bool & out_state) const;
9781 
9785  bool ShowFaces(bool & out_state) const;
9786 
9790  bool ShowVertices(bool & out_state) const;
9791 
9795  bool ShowMarkers(bool & out_state) const;
9796 
9800  bool ShowShadowCasting(bool & out_state) const;
9801 
9805  bool ShowShadowReceiving(bool & out_state) const;
9806 
9810  bool ShowShadowEmitting(bool & out_state) const;
9811 };
9812 
9813 
9819 class HPS_API VisibilityControl : public Control
9820 {
9821 public:
9822 
9824  explicit VisibilityControl(SegmentKey & in_seg);
9825 
9827  VisibilityControl(VisibilityControl const & in_that);
9828 
9833 
9837  VisibilityControl & operator=(VisibilityControl && in_that);
9838 
9840  ~VisibilityControl();
9841 
9842  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
9843 
9845  VisibilityControl & operator=(VisibilityControl const & in_that);
9846 
9847 
9851  VisibilityControl & SetCuttingSections(bool in_state);
9852 
9856  VisibilityControl & SetCutEdges(bool in_state);
9857 
9861  VisibilityControl & SetCutFaces(bool in_state);
9862 
9866  VisibilityControl & SetWindows(bool in_state);
9867 
9871  VisibilityControl & SetText(bool in_state);
9872 
9876  VisibilityControl & SetLines(bool in_state);
9877 
9881  VisibilityControl & SetEdgeLights(bool in_state);
9882 
9886  VisibilityControl & SetMarkerLights(bool in_state);
9887 
9891  VisibilityControl & SetFaceLights(bool in_state);
9892 
9896  VisibilityControl & SetGenericEdges(bool in_state);
9897 
9901  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
9902 
9906  VisibilityControl & SetAdjacentEdges(bool in_state);
9907 
9911  VisibilityControl & SetHardEdges(bool in_state);
9912 
9916  VisibilityControl & SetMeshQuadEdges(bool in_state);
9917 
9921  VisibilityControl & SetNonCulledEdges(bool in_state);
9922 
9926  VisibilityControl & SetPerimeterEdges(bool in_state);
9927 
9931  VisibilityControl & SetFaces(bool in_state);
9932 
9936  VisibilityControl & SetVertices(bool in_state);
9937 
9941  VisibilityControl & SetMarkers(bool in_state);
9942 
9946  VisibilityControl & SetShadowCasting(bool in_state);
9947 
9951  VisibilityControl & SetShadowReceiving(bool in_state);
9952 
9956  VisibilityControl & SetShadowEmitting(bool in_state);
9957 
9958 
9962  VisibilityControl & SetCutGeometry(bool in_state);
9963 
9967  VisibilityControl & SetEdges(bool in_state);
9968 
9972  VisibilityControl & SetGeometry(bool in_state);
9973 
9977  VisibilityControl & SetLights(bool in_state);
9978 
9982  VisibilityControl & SetShadows(bool in_state);
9983 
9987  VisibilityControl & SetEverything(bool in_state);
9988 
9989 
9992  VisibilityControl & UnsetCuttingSections();
9993 
9996  VisibilityControl & UnsetCutEdges();
9997 
10000  VisibilityControl & UnsetCutFaces();
10001 
10004  VisibilityControl & UnsetWindows();
10005 
10008  VisibilityControl & UnsetText();
10009 
10012  VisibilityControl & UnsetLines();
10013 
10016  VisibilityControl & UnsetEdgeLights();
10017 
10020  VisibilityControl & UnsetMarkerLights();
10021 
10024  VisibilityControl & UnsetFaceLights();
10025 
10028  VisibilityControl & UnsetGenericEdges();
10029 
10032  VisibilityControl & UnsetInteriorSilhouetteEdges();
10033 
10036  VisibilityControl & UnsetAdjacentEdges();
10037 
10040  VisibilityControl & UnsetHardEdges();
10041 
10044  VisibilityControl & UnsetMeshQuadEdges();
10045 
10048  VisibilityControl & UnsetNonCulledEdges();
10049 
10052  VisibilityControl & UnsetPerimeterEdges();
10053 
10056  VisibilityControl & UnsetFaces();
10057 
10060  VisibilityControl & UnsetVertices();
10061 
10064  VisibilityControl & UnsetMarkers();
10065 
10068  VisibilityControl & UnsetShadowCasting();
10069 
10072  VisibilityControl & UnsetShadowReceiving();
10073 
10076  VisibilityControl & UnsetShadowEmitting();
10077 
10078 
10081  VisibilityControl & UnsetCutGeometry();
10082 
10085  VisibilityControl & UnsetEdges();
10086 
10089  VisibilityControl & UnsetGeometry();
10090 
10093  VisibilityControl & UnsetLights();
10094 
10097  VisibilityControl & UnsetShadows();
10098 
10101  VisibilityControl & UnsetEverything();
10102 
10103 
10107  bool ShowCuttingSections(bool & out_state) const;
10108 
10112  bool ShowCutEdges(bool & out_state) const;
10113 
10117  bool ShowCutFaces(bool & out_state) const;
10118 
10122  bool ShowWindows(bool & out_state) const;
10123 
10127  bool ShowText(bool & out_state) const;
10128 
10132  bool ShowLines(bool & out_state) const;
10133 
10137  bool ShowEdgeLights(bool & out_state) const;
10138 
10142  bool ShowMarkerLights(bool & out_state) const;
10143 
10147  bool ShowFaceLights(bool & out_state) const;
10148 
10152  bool ShowGenericEdges(bool & out_state) const;
10153 
10157  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10158 
10162  bool ShowAdjacentEdges(bool & out_state) const;
10163 
10167  bool ShowHardEdges(bool & out_state) const;
10168 
10172  bool ShowMeshQuadEdges(bool & out_state) const;
10173 
10177  bool ShowNonCulledEdges(bool & out_state) const;
10178 
10182  bool ShowPerimeterEdges(bool & out_state) const;
10183 
10187  bool ShowFaces(bool & out_state) const;
10188 
10192  bool ShowVertices(bool & out_state) const;
10193 
10197  bool ShowMarkers(bool & out_state) const;
10198 
10202  bool ShowShadowCasting(bool & out_state) const;
10203 
10207  bool ShowShadowReceiving(bool & out_state) const;
10208 
10212  bool ShowShadowEmitting(bool & out_state) const;
10213 
10214 private:
10217 };
10218 
10219 
10220 
10223 class HPS_API CameraKit : public Object
10224 {
10225 public:
10226 
10228  CameraKit();
10229 
10232  CameraKit(const CameraKit & in_kit);
10233 
10237  CameraKit(CameraKit && in_that);
10238 
10242  CameraKit & operator=(CameraKit && in_that);
10243 
10245  virtual ~CameraKit();
10246 
10247  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10248 
10252  static CameraKit GetDefault();
10253 
10256  void Set(CameraKit const & in_kit);
10257 
10260  void Show(CameraKit & out_kit) const;
10261 
10265  CameraKit & operator=(CameraKit const & in_kit);
10266 
10269  bool Empty() const;
10270 
10274  bool Equals(CameraKit const & in_kit) const;
10275 
10279  bool operator==(CameraKit const & in_kit) const;
10280 
10284  bool operator!=(CameraKit const & in_kit) const;
10285 
10289  CameraKit & SetUpVector(Vector const & in_up);
10290 
10294  CameraKit & SetPosition(Point const & in_position);
10295 
10299  CameraKit & SetTarget(Point const & in_target);
10300 
10307  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10308 
10314  CameraKit & SetField(float in_width, float in_height);
10315 
10325  CameraKit & SetNearLimit(float const in_limit);
10326 
10329  CameraKit & UnsetUpVector();
10330 
10333  CameraKit & UnsetPosition();
10334 
10337  CameraKit & UnsetTarget();
10338 
10341  CameraKit & UnsetProjection();
10342 
10345  CameraKit & UnsetField();
10346 
10349  CameraKit & UnsetNearLimit();
10350 
10353  CameraKit & UnsetEverything();
10354 
10355 
10359  bool ShowUpVector(Vector & out_up_vector) const;
10360 
10364  bool ShowPosition(Point & out_position) const;
10365 
10369  bool ShowTarget(Point & out_target) const;
10370 
10374  bool ShowProjection(Camera::Projection & out_type) const;
10375 
10381  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10382 
10386  bool ShowWidth(float & out_width) const;
10387 
10391  bool ShowHeight(float & out_height) const;
10392 
10397  bool ShowField(float & out_width, float & out_height) const;
10398 
10402  bool ShowNearLimit(float & out_near_limit) const;
10403 
10410  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10411 
10418  CameraKit & Orbit(float in_theta, float in_phi);
10419 
10426  CameraKit & Pan(float in_theta, float in_phi);
10427 
10433  CameraKit & Roll(float in_theta);
10434 
10440  CameraKit & Zoom(float in_zoom);
10441 };
10442 
10446 class HPS_API CameraControl : public Control
10447 {
10448 public:
10450  explicit CameraControl(SegmentKey & in_seg);
10451 
10453  CameraControl(CameraControl const & in_that);
10454 
10458  CameraControl(CameraControl && in_that);
10459 
10463  CameraControl & operator=(CameraControl && in_that);
10464 
10466  ~CameraControl();
10467 
10468  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
10469 
10471  CameraControl & operator=(CameraControl const & in_that);
10472 
10473 
10478  CameraControl & SetUpVector(Vector const & in_up);
10479 
10484  CameraControl & SetPosition(Point const & in_position);
10485 
10490  CameraControl & SetTarget(Point const & in_target);
10491 
10498  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10499 
10505  CameraControl & SetField(float in_width, float in_height);
10506 
10517  CameraControl & SetNearLimit(float in_double);
10518 
10522  CameraControl & UnsetEverything();
10523 
10524 
10528  bool ShowUpVector(Vector & out_up_vector) const;
10529 
10533  bool ShowPosition(Point & out_position) const;
10534 
10538  bool ShowTarget(Point & out_target) const;
10539 
10543  bool ShowProjection(Camera::Projection & out_type) const;
10544 
10550  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10551 
10555  bool ShowWidth(float & out_width) const;
10556 
10560  bool ShowHeight(float & out_height) const;
10561 
10566  bool ShowField(float & out_width, float & out_height) const;
10567 
10571  bool ShowNearLimit(float & out_width) const;
10572 
10579  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10580 
10587  CameraControl & Orbit(float in_theta, float in_phi);
10588 
10595  CameraControl & Pan(float in_theta, float in_phi);
10596 
10602  CameraControl & Roll(float in_theta);
10603 
10609  CameraControl & Zoom(float in_zoom);
10610 
10611 private:
10613  CameraControl();
10614 };
10615 
10616 
10617 
10619 class HPS_API SelectabilityKit : public Object
10620 {
10621 public:
10622 
10624  SelectabilityKit();
10625 
10628  SelectabilityKit(SelectabilityKit const & in_kit);
10629 
10633  SelectabilityKit(SelectabilityKit && in_that);
10634 
10638  SelectabilityKit & operator=(SelectabilityKit && in_that);
10639 
10641  virtual ~SelectabilityKit();
10642 
10643  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
10644 
10648  static SelectabilityKit GetDefault();
10649 
10652  void Set(SelectabilityKit const & in_kit);
10653 
10656  void Show(SelectabilityKit & out_kit) const;
10657 
10661  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10662 
10665  bool Empty() const;
10666 
10670  bool Equals(SelectabilityKit const & in_kit) const;
10671 
10675  bool operator==(SelectabilityKit const & in_kit) const;
10676 
10680  bool operator!=(SelectabilityKit const & in_kit) const;
10681 
10682 
10686  SelectabilityKit & SetWindows(Selectability::Value in_val);
10687 
10691  SelectabilityKit & SetEdges(Selectability::Value in_val);
10692 
10696  SelectabilityKit & SetFaces(Selectability::Value in_val);
10697 
10701  SelectabilityKit & SetLights(Selectability::Value in_val);
10702 
10706  SelectabilityKit & SetLines(Selectability::Value in_val);
10707 
10711  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10712 
10716  SelectabilityKit & SetVertices(Selectability::Value in_val);
10717 
10721  SelectabilityKit & SetText(Selectability::Value in_val);
10722 
10726  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10727 
10731  SelectabilityKit & SetEverything(Selectability::Value in_val);
10732 
10733 
10736  SelectabilityKit & UnsetWindows();
10737 
10740  SelectabilityKit & UnsetEdges();
10741 
10744  SelectabilityKit & UnsetFaces();
10745 
10748  SelectabilityKit & UnsetLights();
10749 
10752  SelectabilityKit & UnsetLines();
10753 
10756  SelectabilityKit & UnsetMarkers();
10757 
10760  SelectabilityKit & UnsetVertices();
10761 
10764  SelectabilityKit & UnsetText();
10765 
10768  SelectabilityKit & UnsetGeometry();
10769 
10772  SelectabilityKit & UnsetEverything();
10773 
10774 
10778  bool ShowWindows(Selectability::Value & out_val) const;
10779 
10783  bool ShowEdges(Selectability::Value & out_val) const;
10784 
10788  bool ShowFaces(Selectability::Value & out_val) const;
10789 
10793  bool ShowLights(Selectability::Value & out_val) const;
10794 
10798  bool ShowLines(Selectability::Value & out_val) const;
10799 
10803  bool ShowMarkers(Selectability::Value & out_val) const;
10804 
10808  bool ShowVertices(Selectability::Value & out_val) const;
10809 
10813  bool ShowText(Selectability::Value & out_val) const;
10814 };
10815 
10821 class HPS_API SelectabilityControl : public Control
10822 {
10823 public:
10824 
10826  explicit SelectabilityControl(SegmentKey & in_seg);
10827 
10829  SelectabilityControl(SelectabilityControl const & in_that);
10830 
10835 
10839  SelectabilityControl & operator=(SelectabilityControl && in_that);
10840 
10843 
10844  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
10845 
10847  SelectabilityControl & operator=(SelectabilityControl const & in_that);
10848 
10849 
10853  SelectabilityControl & SetWindows(Selectability::Value in_val);
10854 
10858  SelectabilityControl & SetEdges(Selectability::Value in_val);
10859 
10863  SelectabilityControl & SetFaces(Selectability::Value in_val);
10864 
10868  SelectabilityControl & SetLights(Selectability::Value in_val);
10869 
10873  SelectabilityControl & SetLines(Selectability::Value in_val);
10874 
10878  SelectabilityControl & SetMarkers(Selectability::Value in_val);
10879 
10883  SelectabilityControl & SetVertices(Selectability::Value in_val);
10884 
10888  SelectabilityControl & SetText(Selectability::Value in_val);
10889 
10893  SelectabilityControl & SetGeometry(Selectability::Value in_val);
10894 
10898  SelectabilityControl & SetEverything(Selectability::Value in_val);
10899 
10900 
10903  SelectabilityControl & UnsetWindows();
10904 
10907  SelectabilityControl & UnsetEdges();
10908 
10911  SelectabilityControl & UnsetFaces();
10912 
10915  SelectabilityControl & UnsetLights();
10916 
10919  SelectabilityControl & UnsetLines();
10920 
10923  SelectabilityControl & UnsetMarkers();
10924 
10927  SelectabilityControl & UnsetVertices();
10928 
10931  SelectabilityControl & UnsetText();
10932 
10935  SelectabilityControl & UnsetGeometry();
10936 
10939  SelectabilityControl & UnsetEverything();
10940 
10941 
10945  bool ShowWindows(Selectability::Value & out_val) const;
10946 
10950  bool ShowEdges(Selectability::Value & out_val) const;
10951 
10955  bool ShowFaces(Selectability::Value & out_val) const;
10956 
10960  bool ShowLights(Selectability::Value & out_val) const;
10961 
10965  bool ShowLines(Selectability::Value & out_val) const;
10966 
10970  bool ShowMarkers(Selectability::Value & out_val) const;
10971 
10975  bool ShowVertices(Selectability::Value & out_val) const;
10976 
10980  bool ShowText(Selectability::Value & out_val) const;
10981 
10982 private:
10985 };
10986 
10987 
10989 class HPS_API TransparencyKit : public Object
10990 {
10991 public:
10992 
10994  TransparencyKit();
10995 
10998  TransparencyKit(TransparencyKit const & in_kit);
10999 
11003  TransparencyKit(TransparencyKit && in_that);
11004 
11008  TransparencyKit & operator=(TransparencyKit && in_that);
11009 
11011  virtual ~TransparencyKit();
11012 
11013  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11014 
11018  static TransparencyKit GetDefault();
11019 
11022  void Set(TransparencyKit const & in_kit);
11023 
11026  void Show(TransparencyKit & out_kit) const;
11027 
11031  TransparencyKit & operator=(TransparencyKit const & in_kit);
11032 
11035  bool Empty() const;
11036 
11040  bool Equals(TransparencyKit const & in_kit) const;
11041 
11045  bool operator==(TransparencyKit const & in_kit) const;
11046 
11050  bool operator!=(TransparencyKit const & in_kit) const;
11051 
11052 
11056  TransparencyKit & SetMethod(Transparency::Method in_style);
11057 
11061  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11062 
11067  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11068 
11074  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11075 
11080  TransparencyKit & SetDepthWriting(bool in_state);
11081 
11082 
11085  TransparencyKit & UnsetMethod();
11086 
11089  TransparencyKit & UnsetAlgorithm();
11090 
11093  TransparencyKit & UnsetDepthPeelingLayers();
11094 
11097  TransparencyKit & UnsetDepthPeelingMinimumArea();
11098 
11101  TransparencyKit & UnsetDepthWriting();
11102 
11105  TransparencyKit & UnsetEverything();
11106 
11107 
11111  bool ShowMethod(Transparency::Method & out_style) const;
11112 
11116  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11117 
11121  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11122 
11127  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11128 
11132  bool ShowDepthWriting(bool & out_state) const;
11133 };
11134 
11140 class HPS_API TransparencyControl : public Control
11141 {
11142 public:
11143 
11145  explicit TransparencyControl(SegmentKey & in_seg);
11146 
11148  TransparencyControl(TransparencyControl const & in_that);
11149 
11154 
11158  TransparencyControl & operator=(TransparencyControl && in_that);
11159 
11162 
11163  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11164 
11166  TransparencyControl & operator=(TransparencyControl const & in_that);
11167 
11171  TransparencyControl & SetMethod(Transparency::Method in_style);
11172 
11176  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11177 
11182  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11183 
11189  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11190 
11195  TransparencyControl & SetDepthWriting(bool in_state);
11196 
11197 
11200  TransparencyControl & UnsetMethod();
11201 
11204  TransparencyControl & UnsetAlgorithm();
11205 
11208  TransparencyControl & UnsetDepthPeelingLayers();
11209 
11212  TransparencyControl & UnsetDepthPeelingMinimumArea();
11213 
11216  TransparencyControl & UnsetDepthWriting();
11217 
11220  TransparencyControl & UnsetEverything();
11221 
11222 
11226  bool ShowMethod(Transparency::Method & out_style) const;
11227 
11231  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11232 
11236  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11237 
11242  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11243 
11247  bool ShowDepthWriting(bool & out_state) const;
11248 
11249 private:
11252 };
11253 
11255 class HPS_API ColorInterpolationKit : public Object
11256 {
11257 public:
11258 
11261 
11264 
11269 
11273  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11274 
11276  virtual ~ColorInterpolationKit();
11277 
11278  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11279 
11280  static ColorInterpolationKit GetDefault();
11281 
11283  void Set(ColorInterpolationKit const & in_kit);
11284 
11286  void Show(ColorInterpolationKit & out_kit) const;
11287 
11289  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
11290 
11292  bool Empty() const;
11293 
11295  bool Equals(ColorInterpolationKit const & in_kit) const;
11296 
11298  bool operator==(ColorInterpolationKit const & in_kit) const;
11299 
11301  bool operator!=(ColorInterpolationKit const & in_kit) const;
11302 
11303 
11307  ColorInterpolationKit & SetFaceColor(bool in_state);
11308 
11312  ColorInterpolationKit & SetEdgeColor(bool in_state);
11313 
11317  ColorInterpolationKit & SetVertexColor(bool in_state);
11318 
11322  ColorInterpolationKit & SetFaceIndex(bool in_state);
11323 
11327  ColorInterpolationKit & SetEdgeIndex(bool in_state);
11328 
11332  ColorInterpolationKit & SetVertexIndex(bool in_state);
11333 
11334 
11337  ColorInterpolationKit & UnsetFaceColor();
11338 
11341  ColorInterpolationKit & UnsetEdgeColor();
11342 
11345  ColorInterpolationKit & UnsetVertexColor();
11346 
11349  ColorInterpolationKit & UnsetFaceIndex();
11350 
11353  ColorInterpolationKit & UnsetEdgeIndex();
11354 
11357  ColorInterpolationKit & UnsetVertexIndex();
11358 
11361  ColorInterpolationKit & UnsetEverything();
11362 
11363 
11367  bool ShowFaceColor(bool & out_state) const;
11368 
11372  bool ShowEdgeColor(bool & out_state) const;
11373 
11377  bool ShowVertexColor(bool & out_state) const;
11378 
11382  bool ShowFaceIndex(bool & out_state) const;
11383 
11387  bool ShowEdgeIndex(bool & out_state) const;
11388 
11392  bool ShowVertexIndex(bool & out_state) const;
11393 };
11394 
11395 
11399 class HPS_API ColorInterpolationControl : public Control
11400 {
11401 public:
11402 
11404  explicit ColorInterpolationControl(SegmentKey & in_seg);
11405 
11408 
11413 
11417  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11418 
11421 
11422  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
11423 
11424 
11428  ColorInterpolationControl & SetFaceColor(bool in_state);
11429 
11433  ColorInterpolationControl & SetEdgeColor(bool in_state);
11434 
11438  ColorInterpolationControl & SetVertexColor(bool in_state);
11439 
11443  ColorInterpolationControl & SetFaceIndex(bool in_state);
11444 
11448  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11449 
11453  ColorInterpolationControl & SetVertexIndex(bool in_state);
11454 
11455 
11458  ColorInterpolationControl & UnsetFaceColor();
11459 
11462  ColorInterpolationControl & UnsetEdgeColor();
11463 
11466  ColorInterpolationControl & UnsetVertexColor();
11467 
11470  ColorInterpolationControl & UnsetFaceIndex();
11471 
11474  ColorInterpolationControl & UnsetEdgeIndex();
11475 
11478  ColorInterpolationControl & UnsetVertexIndex();
11479 
11482  ColorInterpolationControl & UnsetEverything();
11483 
11484 
11488  bool ShowFaceColor(bool & out_state) const;
11489 
11493  bool ShowEdgeColor(bool & out_state) const;
11494 
11498  bool ShowVertexColor(bool & out_state) const;
11499 
11503  bool ShowFaceIndex(bool & out_state) const;
11504 
11508  bool ShowEdgeIndex(bool & out_state) const;
11509 
11513  bool ShowVertexIndex(bool & out_state) const;
11514 
11515 private:
11518 };
11519 
11520 
11522 class HPS_API CullingKit : public Object
11523 {
11524 public:
11525 
11527  CullingKit();
11528 
11531  CullingKit(CullingKit const & in_kit);
11532 
11536  CullingKit(CullingKit && in_that);
11537 
11541  CullingKit & operator=(CullingKit && in_that);
11542 
11544  virtual ~CullingKit();
11545 
11546  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
11547 
11551  static CullingKit GetDefault();
11552 
11555  void Set(CullingKit const & in_kit);
11556 
11559  void Show(CullingKit & out_kit) const;
11560 
11564  CullingKit & operator=(CullingKit const & in_kit);
11565 
11568  bool Empty() const;
11569 
11573  bool Equals(CullingKit const & in_kit) const;
11574 
11578  bool operator==(CullingKit const & in_kit) const;
11579 
11583  bool operator!=(CullingKit const & in_kit) const;
11584 
11589  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11590 
11595  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11596 
11601  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11602 
11607  CullingKit & SetExtent(unsigned int in_pixels);
11608 
11612  CullingKit & SetBackFace(bool in_state);
11613 
11620  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11621 
11628  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11629 
11636  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11637 
11643  CullingKit & SetVector(HPS::Vector const & in_vector);
11644 
11648  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11649 
11653  CullingKit & SetFrustum(bool in_state);
11654 
11657  CullingKit & UnsetDeferralExtent();
11658 
11661  CullingKit & UnsetExtent();
11662 
11665  CullingKit & UnsetBackFace();
11666 
11669  CullingKit & UnsetVector();
11670 
11673  CullingKit & UnsetVectorTolerance();
11674 
11677  CullingKit & UnsetFrustum();
11678 
11681  CullingKit & UnsetEverything();
11682 
11687  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11688 
11693  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11694 
11698  bool ShowBackFace(bool & out_state) const;
11699 
11705  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11706 
11710  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11711 
11715  bool ShowFrustum(bool & out_state) const;
11716 };
11717 
11721 class HPS_API CullingControl : public Control
11722 {
11723 public:
11724 
11726  explicit CullingControl(SegmentKey & in_seg);
11727 
11729  CullingControl(CullingControl const & in_that);
11730 
11732  ~CullingControl();
11733 
11737  CullingControl(CullingControl && in_that);
11738 
11742  CullingControl & operator=(CullingControl && in_that);
11743 
11744  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
11745 
11747  CullingControl & operator=(CullingControl const & in_that);
11748 
11755  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11756 
11763  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11764 
11769  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11770 
11775  CullingControl & SetExtent(unsigned int in_pixels);
11776 
11781  CullingControl & SetBackFace(bool in_state);
11782 
11789  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
11790 
11797  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
11798 
11805  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11806 
11812  CullingControl & SetVector(HPS::Vector const & in_vector);
11813 
11817  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
11818 
11822  CullingControl & SetFrustum(bool in_state);
11823 
11826  CullingControl & UnsetDeferralExtent();
11827 
11830  CullingControl & UnsetExtent();
11831 
11834  CullingControl & UnsetBackFace();
11835 
11838  CullingControl & UnsetVector();
11839 
11842  CullingControl & UnsetVectorTolerance();
11843 
11846  CullingControl & UnsetFrustum();
11847 
11850  CullingControl & UnsetEverything();
11851 
11856  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11857 
11862  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11863 
11867  bool ShowBackFace(bool & out_state) const;
11868 
11874  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
11875 
11879  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11880 
11884  bool ShowFrustum(bool & out_state) const;
11885 
11886 private:
11888  CullingControl();
11889 };
11890 
11891 
11892 
11893 
11895 class HPS_API MarkerAttributeKit : public Object
11896 {
11897 public:
11898 
11901 
11904  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
11905 
11910 
11914  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
11915 
11917  virtual ~MarkerAttributeKit();
11918 
11919  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
11920 
11924  static MarkerAttributeKit GetDefault();
11925 
11928  void Set(MarkerAttributeKit const & in_kit);
11929 
11932  void Show(MarkerAttributeKit & out_kit) const;
11933 
11937  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
11938 
11941  bool Empty() const;
11942 
11946  bool Equals(MarkerAttributeKit const & in_kit) const;
11947 
11951  bool operator==(MarkerAttributeKit const & in_kit) const;
11952 
11956  bool operator!=(MarkerAttributeKit const & in_kit) const;
11957 
11958 
11962  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
11963 
11968  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
11969 
11970 
11973  MarkerAttributeKit & UnsetSymbol();
11974 
11977  MarkerAttributeKit & UnsetSize();
11978 
11981  MarkerAttributeKit & UnsetEverything();
11982 
11983 
11987  bool ShowSymbol(UTF8 & out_glyph_name) const;
11988 
11993  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
11994 };
11995 
12001 class HPS_API MarkerAttributeControl : public Control
12002 {
12003 public:
12004 
12006  explicit MarkerAttributeControl(SegmentKey & in_seg);
12007 
12010 
12015 
12019  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12020 
12023 
12024  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12025 
12027  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12028 
12032  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12033 
12038  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12039 
12040 
12043  MarkerAttributeControl & UnsetSymbol();
12044 
12047  MarkerAttributeControl & UnsetSize();
12048 
12051  MarkerAttributeControl & UnsetEverything();
12052 
12053 
12057  bool ShowSymbol(UTF8 & out_glyph_name) const;
12058 
12063  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12064 
12065 private:
12068 };
12069 
12070 
12072 class HPS_API SphereAttributeKit : public Object
12073 {
12074 public:
12075 
12078 
12081  SphereAttributeKit(SphereAttributeKit const & in_kit);
12082 
12087 
12091  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12092 
12094  virtual ~SphereAttributeKit();
12095 
12096  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12097 
12101  static SphereAttributeKit GetDefault();
12102 
12105  void Set(SphereAttributeKit const & in_kit);
12106 
12109  void Show(SphereAttributeKit & out_kit) const;
12110 
12114  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12115 
12118  bool Empty() const;
12119 
12123  bool Equals(SphereAttributeKit const & in_kit) const;
12124 
12128  bool operator==(SphereAttributeKit const & in_kit) const;
12129 
12133  bool operator!=(SphereAttributeKit const & in_kit) const;
12134 
12135 
12139  SphereAttributeKit & SetTessellation(size_t in_facets);
12140 
12141 
12144  SphereAttributeKit & UnsetTessellation();
12145 
12148  SphereAttributeKit & UnsetEverything();
12149 
12150 
12154  bool ShowTessellation(size_t & out_facets) const;
12155 };
12156 
12157 
12160 class HPS_API SphereAttributeControl : public Control
12161 {
12162 public:
12163 
12165  explicit SphereAttributeControl(SegmentKey const & in_seg);
12166 
12169 
12174 
12178  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12179 
12182 
12183  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12184 
12186  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12187 
12188 
12193  SphereAttributeControl & SetTessellation(size_t in_facets);
12194 
12195 
12198  SphereAttributeControl & UnsetTessellation();
12199 
12202  SphereAttributeControl & UnsetEverything();
12203 
12204 
12208  bool ShowTessellation(size_t & out_facets) const;
12209 
12210 private:
12213 };
12214 
12215 
12217 class HPS_API LightingAttributeKit : public Object
12218 {
12219 public:
12220 
12223 
12227 
12232 
12236  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12237 
12239  virtual ~LightingAttributeKit();
12240 
12241  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12242 
12246  static LightingAttributeKit GetDefault();
12247 
12250  void Set(LightingAttributeKit const & in_kit);
12251 
12254  void Show(LightingAttributeKit & out_kit) const;
12255 
12259  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
12260 
12263  bool Empty() const;
12264 
12268  bool Equals(LightingAttributeKit const & in_kit) const;
12269 
12273  bool operator==(LightingAttributeKit const & in_kit) const;
12274 
12278  bool operator!=(LightingAttributeKit const & in_kit) const;
12279 
12280 
12284  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12285 
12286 
12289  LightingAttributeKit & UnsetInterpolationAlgorithm();
12290 
12293  LightingAttributeKit & UnsetEverything();
12294 
12295 
12299  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12300 };
12301 
12302 
12303 
12309 class HPS_API LightingAttributeControl : public Control
12310 {
12311 public:
12312 
12314  explicit LightingAttributeControl(SegmentKey & in_seg);
12315 
12318 
12323 
12327  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
12328 
12331 
12332  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
12333 
12335  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
12336 
12337 
12341  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
12342 
12343 
12346  LightingAttributeControl & UnsetInterpolationAlgorithm();
12347 
12350  LightingAttributeControl & UnsetEverything();
12351 
12352 
12356  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
12357 
12358 private:
12361 };
12362 
12363 
12364 
12366 class HPS_API CylinderAttributeKit : public Object
12367 {
12368 public:
12369 
12372 
12376 
12381 
12385  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
12386 
12388  virtual ~CylinderAttributeKit();
12389 
12390  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
12391 
12395  static CylinderAttributeKit GetDefault();
12396 
12399  void Set(CylinderAttributeKit const & in_kit);
12400 
12403  void Show(CylinderAttributeKit & out_kit) const;
12404 
12408  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
12409 
12412  bool Empty() const;
12413 
12417  bool Equals(CylinderAttributeKit const & in_kit) const;
12418 
12422  bool operator==(CylinderAttributeKit const & in_kit) const;
12423 
12427  bool operator!=(CylinderAttributeKit const & in_kit) const;
12428 
12429 
12433  CylinderAttributeKit & SetTessellation(size_t in_facets);
12434 
12439  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12440 
12441 
12444  CylinderAttributeKit & UnsetTessellation();
12445 
12448  CylinderAttributeKit & UnsetOrientation();
12449 
12452  CylinderAttributeKit & UnsetEverything();
12453 
12454 
12458  bool ShowTessellation(size_t & out_facets) const;
12459 
12463  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12464 };
12465 
12466 
12467 
12471 class HPS_API CylinderAttributeControl : public Control
12472 {
12473 public:
12474 
12476  explicit CylinderAttributeControl(SegmentKey & in_seg);
12477 
12480 
12485 
12489  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12490 
12493 
12494  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
12495 
12497  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12498 
12499 
12503  CylinderAttributeControl & SetTessellation(size_t in_facets);
12504 
12509  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12510 
12511 
12514  CylinderAttributeControl & UnsetTessellation();
12515 
12518  CylinderAttributeControl & UnsetOrientation();
12519 
12522  CylinderAttributeControl & UnsetEverything();
12523 
12524 
12528  bool ShowTessellation(size_t & out_facets) const;
12529 
12533  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12534 
12535 private:
12538 };
12539 
12540 
12541 
12543 class HPS_API CuttingSectionAttributeKit : public Object
12544 {
12545 public:
12546 
12549 
12553 
12558 
12563 
12565  virtual ~CuttingSectionAttributeKit();
12566 
12567  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
12568 
12572  static CuttingSectionAttributeKit GetDefault();
12573 
12576  void Set(CuttingSectionAttributeKit const & in_kit);
12577 
12580  void Show(CuttingSectionAttributeKit & out_kit) const;
12581 
12585  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12586 
12589  bool Empty() const;
12590 
12594  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12595 
12599  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12600 
12604  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12605 
12606 
12610  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12611 
12615  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12616 
12620  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12621 
12622 
12625  CuttingSectionAttributeKit & UnsetCuttingLevel();
12626 
12629  CuttingSectionAttributeKit & UnsetCappingLevel();
12630 
12633  CuttingSectionAttributeKit & UnsetMaterialPreference();
12634 
12637  CuttingSectionAttributeKit & UnsetEverything();
12638 
12639 
12643  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12644 
12648  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12649 
12653  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12654 };
12655 
12656 
12657 
12662 {
12663 public:
12664 
12666  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12667 
12670 
12675 
12680 
12683 
12684  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
12685 
12688 
12689 
12694 
12699 
12703  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12704 
12705 
12708  CuttingSectionAttributeControl & UnsetCuttingLevel();
12709 
12712  CuttingSectionAttributeControl & UnsetCappingLevel();
12713 
12716  CuttingSectionAttributeControl & UnsetMaterialPreference();
12717 
12720  CuttingSectionAttributeControl & UnsetEverything();
12721 
12722 
12726  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12727 
12731  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12732 
12736  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12737 
12738 private:
12741 };
12742 
12743 
12744 
12746 class HPS_API TextAttributeKit : public Object
12747 {
12748 public:
12749 
12751  TextAttributeKit();
12752 
12755  TextAttributeKit(TextAttributeKit const & in_kit);
12756 
12760  TextAttributeKit(TextAttributeKit && in_that);
12761 
12765  TextAttributeKit & operator=(TextAttributeKit && in_that);
12766 
12768  virtual ~TextAttributeKit();
12769 
12770  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
12771 
12775  static TextAttributeKit GetDefault();
12776 
12779  void Set(TextAttributeKit const & in_kit);
12780 
12783  void Show(TextAttributeKit & out_kit) const;
12784 
12788  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12789 
12792  bool Empty() const;
12793 
12797  bool Equals(TextAttributeKit const & in_kit) const;
12798 
12802  bool operator==(TextAttributeKit const & in_kit) const;
12803 
12807  bool operator!=(TextAttributeKit const & in_kit) const;
12808 
12809 
12816 
12821  TextAttributeKit & SetBold(bool in_state);
12822 
12827  TextAttributeKit & SetItalic(bool in_state);
12828 
12832  TextAttributeKit & SetOverline(bool in_state);
12833 
12837  TextAttributeKit & SetStrikethrough(bool in_state);
12838 
12842  TextAttributeKit & SetUnderline(bool in_state);
12843 
12849  TextAttributeKit & SetSlant(float in_angle);
12850 
12855  TextAttributeKit & SetLineSpacing(float in_multiplier);
12856 
12861  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12862 
12867  TextAttributeKit & SetRotation(float in_angle);
12868 
12874  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12875 
12881  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12882 
12889  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12890 
12897 
12907  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12908 
12918  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
12919 
12924  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
12925 
12932  TextAttributeKit & SetFont(char const * in_name);
12933 
12937  TextAttributeKit & SetTransform(Text::Transform in_trans);
12938 
12942  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
12943 
12948  TextAttributeKit & SetPreference(Text::Preference in_pref);
12949 
12957  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
12958 
12963  TextAttributeKit & SetPath(Vector const & in_path);
12964 
12972  TextAttributeKit & SetSpacing(float in_multiplier);
12973 
12974 
12977  TextAttributeKit & UnsetAlignment();
12978 
12981  TextAttributeKit & UnsetBold();
12982 
12985  TextAttributeKit & UnsetItalic();
12986 
12989  TextAttributeKit & UnsetOverline();
12990 
12993  TextAttributeKit & UnsetStrikethrough();
12994 
12997  TextAttributeKit & UnsetUnderline();
12998 
13001  TextAttributeKit & UnsetSlant();
13002 
13005  TextAttributeKit & UnsetLineSpacing();
13006 
13009  TextAttributeKit & UnsetRotation();
13010 
13013  TextAttributeKit & UnsetExtraSpace();
13014 
13017  TextAttributeKit & UnsetGreeking();
13018 
13021  TextAttributeKit & UnsetSizeTolerance();
13022 
13025  TextAttributeKit & UnsetSize();
13026 
13029  TextAttributeKit & UnsetFont();
13030 
13033  TextAttributeKit & UnsetTransform();
13034 
13037  TextAttributeKit & UnsetRenderer();
13038 
13041  TextAttributeKit & UnsetPreference();
13042 
13045  TextAttributeKit & UnsetPath();
13046 
13049  TextAttributeKit & UnsetSpacing();
13050 
13053  TextAttributeKit & UnsetEverything();
13054 
13055 
13061  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13062 
13066  bool ShowBold(bool & out_state) const;
13067 
13071  bool ShowItalic(bool & out_state) const;
13072 
13076  bool ShowOverline(bool & out_state) const;
13077 
13081  bool ShowStrikethrough(bool & out_state) const;
13082 
13086  bool ShowUnderline(bool & out_state) const;
13087 
13091  bool ShowSlant(float & out_angle) const;
13092 
13096  bool ShowLineSpacing(float & out_multiplier) const;
13097 
13102  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13103 
13109  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13110 
13117  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13118 
13124  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13125 
13130  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13131 
13135  bool ShowFont(UTF8 & out_name) const;
13136 
13140  bool ShowTransform(Text::Transform & out_trans) const;
13141 
13145  bool ShowRenderer(Text::Renderer & out_rend) const;
13146 
13153  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13154 
13158  bool ShowPath(Vector & out_path) const;
13159 
13163  bool ShowSpacing(float & out_multiplier) const;
13164 };
13165 
13171 class HPS_API TextAttributeControl : public Control
13172 {
13173 public:
13174 
13176  explicit TextAttributeControl(SegmentKey & in_seg);
13177 
13179  TextAttributeControl(TextAttributeControl const & in_that);
13180 
13185 
13189  TextAttributeControl & operator=(TextAttributeControl && in_that);
13190 
13193 
13194  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
13195 
13197  TextAttributeControl & operator=(TextAttributeControl const & in_that);
13198 
13199 
13206 
13211  TextAttributeControl & SetBold(bool in_state);
13212 
13217  TextAttributeControl & SetItalic(bool in_state);
13218 
13222  TextAttributeControl & SetOverline(bool in_state);
13223 
13227  TextAttributeControl & SetStrikethrough(bool in_state);
13228 
13232  TextAttributeControl & SetUnderline(bool in_state);
13233 
13239  TextAttributeControl & SetSlant(float in_angle);
13240 
13245  TextAttributeControl & SetLineSpacing(float in_multiplier);
13246 
13251  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13252 
13257  TextAttributeControl & SetRotation(float in_angle);
13258 
13264  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13265 
13271  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13272 
13279  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13280 
13287 
13297  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13298 
13308  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13309 
13314  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
13315 
13322  TextAttributeControl & SetFont(char const * in_name);
13323 
13327  TextAttributeControl & SetTransform(Text::Transform in_trans);
13328 
13332  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
13333 
13338  TextAttributeControl & SetPreference(Text::Preference in_pref);
13339 
13347  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13348 
13353  TextAttributeControl & SetPath(Vector const & in_path);
13354 
13362  TextAttributeControl & SetSpacing(float in_multiplier);
13363 
13364 
13367  TextAttributeControl & UnsetAlignment();
13368 
13371  TextAttributeControl & UnsetBold();
13372 
13375  TextAttributeControl & UnsetItalic();
13376 
13379  TextAttributeControl & UnsetOverline();
13380 
13383  TextAttributeControl & UnsetStrikethrough();
13384 
13387  TextAttributeControl & UnsetUnderline();
13388 
13391  TextAttributeControl & UnsetSlant();
13392 
13395  TextAttributeControl & UnsetLineSpacing();
13396 
13399  TextAttributeControl & UnsetRotation();
13400 
13403  TextAttributeControl & UnsetExtraSpace();
13404 
13407  TextAttributeControl & UnsetGreeking();
13408 
13411  TextAttributeControl & UnsetSizeTolerance();
13412 
13415  TextAttributeControl & UnsetSize();
13416 
13419  TextAttributeControl & UnsetFont();
13420 
13423  TextAttributeControl & UnsetTransform();
13424 
13427  TextAttributeControl & UnsetRenderer();
13428 
13431  TextAttributeControl & UnsetPreference();
13432 
13435  TextAttributeControl & UnsetPath();
13436 
13439  TextAttributeControl & UnsetSpacing();
13440 
13443  TextAttributeControl & UnsetEverything();
13444 
13445 
13451  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13452 
13456  bool ShowBold(bool & out_state) const;
13457 
13461  bool ShowItalic(bool & out_state) const;
13462 
13466  bool ShowOverline(bool & out_state) const;
13467 
13471  bool ShowStrikethrough(bool & out_state) const;
13472 
13476  bool ShowUnderline(bool & out_state) const;
13477 
13481  bool ShowSlant(float & out_angle) const;
13482 
13486  bool ShowLineSpacing(float & out_multiplier) const;
13487 
13492  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13493 
13499  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13500 
13507  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13508 
13514  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13515 
13520  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13521 
13525  bool ShowFont(UTF8 & out_name) const;
13526 
13530  bool ShowTransform(Text::Transform & out_trans) const;
13531 
13535  bool ShowRenderer(Text::Renderer & out_rend) const;
13536 
13543  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13544 
13548  bool ShowPath(Vector & out_path) const;
13549 
13553  bool ShowSpacing(float & out_multiplier) const;
13554 
13555 private:
13558 };
13559 
13560 
13561 
13562 
13563 
13565 class HPS_API LineAttributeKit : public Object
13566 {
13567 public:
13568 
13570  LineAttributeKit();
13571 
13574  LineAttributeKit(LineAttributeKit const & in_kit);
13575 
13579  LineAttributeKit(LineAttributeKit && in_that);
13580 
13584  LineAttributeKit & operator=(LineAttributeKit && in_that);
13585 
13587  virtual ~LineAttributeKit();
13588 
13589  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
13590 
13594  static LineAttributeKit GetDefault();
13595 
13598  void Set(LineAttributeKit const & in_kit);
13599 
13602  void Show(LineAttributeKit & out_kit) const;
13603 
13607  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13608 
13611  bool Empty() const;
13612 
13616  bool Equals(LineAttributeKit const & in_kit) const;
13617 
13621  bool operator==(LineAttributeKit const & in_kit) const;
13622 
13626  bool operator!=(LineAttributeKit const & in_kit) const;
13627 
13628 
13632  LineAttributeKit & SetPattern(char const * in_name);
13633 
13638  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13639 
13644  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13645 
13646 
13649  LineAttributeKit & UnsetPattern();
13650 
13653  LineAttributeKit & UnsetWeight();
13654 
13657  LineAttributeKit & UnsetEverything();
13658 
13659 
13664  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13665 
13670  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13671 };
13672 
13678 class HPS_API LineAttributeControl : public Control
13679 {
13680 public:
13681 
13683  explicit LineAttributeControl(SegmentKey & in_seg);
13684 
13686  LineAttributeControl(LineAttributeControl const & in_that);
13687 
13692 
13696  LineAttributeControl & operator=(LineAttributeControl && in_that);
13697 
13700 
13701  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
13702 
13704  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13705 
13706 
13710  LineAttributeControl & SetPattern(char const * in_pattern);
13711 
13716  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13717 
13722  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13723 
13724 
13727  LineAttributeControl & UnsetPattern();
13728 
13731  LineAttributeControl & UnsetWeight();
13732 
13735  LineAttributeControl & UnsetEverything();
13736 
13737 
13742  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13743 
13748  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13749 
13750 private:
13753 };
13754 
13755 
13756 
13758 class HPS_API EdgeAttributeKit : public Object
13759 {
13760 public:
13761 
13763  EdgeAttributeKit();
13764 
13767  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13768 
13772  EdgeAttributeKit(EdgeAttributeKit && in_that);
13773 
13777  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13778 
13780  virtual ~EdgeAttributeKit();
13781 
13782  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
13783 
13787  static EdgeAttributeKit GetDefault();
13788 
13791  void Set(EdgeAttributeKit const & in_kit);
13792 
13795  void Show(EdgeAttributeKit & out_kit) const;
13796 
13800  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13801 
13804  bool Empty() const;
13805 
13809  bool Equals(EdgeAttributeKit const & in_kit) const;
13810 
13814  bool operator==(EdgeAttributeKit const & in_kit) const;
13815 
13819  bool operator!=(EdgeAttributeKit const & in_kit) const;
13820 
13821 
13825  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
13826 
13831  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13832 
13833 
13836  EdgeAttributeKit & UnsetPattern();
13837 
13840  EdgeAttributeKit & UnsetWeight();
13841 
13844  EdgeAttributeKit & UnsetEverything();
13845 
13846 
13850  bool ShowPattern(UTF8 & out_pattern_name) const;
13851 
13856  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13857 };
13858 
13864 class HPS_API EdgeAttributeControl : public Control
13865 {
13866 public:
13867 
13869  explicit EdgeAttributeControl(SegmentKey & in_seg);
13870 
13872  EdgeAttributeControl(EdgeAttributeControl const & in_that);
13873 
13878 
13882  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
13883 
13886 
13887  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
13888 
13890  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
13891 
13895  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
13896 
13901  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13902 
13903 
13906  EdgeAttributeControl & UnsetPattern();
13907 
13910  EdgeAttributeControl & UnsetWeight();
13911 
13914  EdgeAttributeControl & UnsetEverything();
13915 
13916 
13920  bool ShowPattern(UTF8 & out_pattern_name) const;
13921 
13926  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13927 
13928 private:
13931 };
13932 
13933 
13935 class HPS_API CurveAttributeKit : public Object
13936 {
13937 public:
13938 
13941 
13944  CurveAttributeKit(CurveAttributeKit const & in_kit);
13945 
13950 
13954  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
13955 
13957  virtual ~CurveAttributeKit();
13958 
13959  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
13960 
13964  static CurveAttributeKit GetDefault();
13965 
13968  void Set(CurveAttributeKit const & in_kit);
13969 
13972  void Show(CurveAttributeKit & out_kit) const;
13973 
13977  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
13978 
13981  bool Empty() const;
13982 
13986  bool Equals(CurveAttributeKit const & in_kit) const;
13987 
13991  bool operator==(CurveAttributeKit const & in_kit) const;
13992 
13996  bool operator!=(CurveAttributeKit const & in_kit) const;
13997 
13998  //Set
13999  CurveAttributeKit & SetBudget(size_t in_budget);
14000 
14007  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14008 
14015  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
14016 
14017 
14024  CurveAttributeKit & SetViewDependent(bool in_state);
14025 
14029  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
14030 
14035  CurveAttributeKit & SetMaximumAngle(float in_degrees);
14036 
14041  CurveAttributeKit & SetMaximumLength(float in_length);
14042 
14043 
14046  CurveAttributeKit & UnsetBudget();
14047 
14050  CurveAttributeKit & UnsetContinuedBudget();
14051 
14054  CurveAttributeKit & UnsetViewDependent();
14055 
14058  CurveAttributeKit & UnsetMaximumDeviation();
14059 
14062  CurveAttributeKit & UnsetMaximumAngle();
14063 
14066  CurveAttributeKit & UnsetMaximumLength();
14067 
14070  CurveAttributeKit & UnsetEverything();
14071 
14072 
14076  bool ShowBudget(size_t & out_budget) const;
14077 
14082  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14083 
14087  bool ShowViewDependent(bool & out_state) const;
14088 
14093  bool ShowMaximumDeviation(float & out_deviation) const;
14094 
14099  bool ShowMaximumAngle(float & out_degrees) const;
14100 
14105  bool ShowMaximumLength(float & out_length) const;
14106 };
14107 
14108 
14112 class HPS_API CurveAttributeControl : public Control
14113 {
14114 public:
14115 
14117  explicit CurveAttributeControl(SegmentKey & in_seg);
14118 
14121 
14126 
14130  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
14131 
14134 
14135  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
14136 
14138  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
14139 
14143  CurveAttributeControl & SetBudget(size_t in_budget);
14144 
14151  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
14152 
14159  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
14160 
14167  CurveAttributeControl & SetViewDependent(bool in_state);
14168 
14172  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
14173 
14178  CurveAttributeControl & SetMaximumAngle(float in_degrees);
14179 
14184  CurveAttributeControl & SetMaximumLength(float in_length);
14185 
14186 
14189  CurveAttributeControl & UnsetBudget();
14190 
14193  CurveAttributeControl & UnsetContinuedBudget();
14194 
14197  CurveAttributeControl & UnsetViewDependent();
14198 
14201  CurveAttributeControl & UnsetMaximumDeviation();
14202 
14205  CurveAttributeControl & UnsetMaximumAngle();
14206 
14209  CurveAttributeControl & UnsetMaximumLength();
14210 
14213  CurveAttributeControl & UnsetEverything();
14214 
14215 
14219  bool ShowBudget(size_t & out_budget) const;
14220 
14225  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
14226 
14230  bool ShowViewDependent(bool & out_state) const;
14231 
14236  bool ShowMaximumDeviation(float & out_deviation) const;
14237 
14242  bool ShowMaximumAngle(float & out_degrees) const;
14243 
14248  bool ShowMaximumLength(float & out_length) const;
14249 
14250 private:
14253 };
14254 
14255 
14256 
14257 
14259 class HPS_API MatrixKit : public Object
14260 {
14261 public:
14262 
14264  MatrixKit();
14265 
14268  MatrixKit(MatrixKit const & in_kit);
14269 
14273  MatrixKit(MatrixKit && in_that);
14274 
14278  MatrixKit & operator=(MatrixKit && in_that);
14279 
14283  MatrixKit(FloatArray const & in_matrix_source);
14284 
14288  MatrixKit(float const in_matrix_source []);
14289 
14292  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
14293 
14295  virtual ~MatrixKit();
14296 
14297  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
14298 
14301  static MatrixKit GetDefault();
14302 
14305  void Set(MatrixKit const & in_kit);
14306 
14309  void Show(MatrixKit & out_kit) const;
14310 
14314  MatrixKit & operator=(MatrixKit const & in_kit);
14315 
14318  bool Empty() const;
14319 
14323  bool Equals(MatrixKit const & in_kit) const;
14324 
14328  bool operator==(MatrixKit const & in_kit) const;
14329 
14333  bool operator!=(MatrixKit const & in_kit) const;
14334 
14340  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
14341 
14346  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14347 
14351  MatrixKit & SetElements(FloatArray const & in_matrix);
14352 
14357  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
14358 
14359 
14362  MatrixKit & UnsetEverything();
14363 
14364 
14370  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14371 
14376  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14377 
14381  bool ShowElements(FloatArray & out_matrix) const;
14382 
14386  bool ShowDeterminant(float & out_determinant) const;
14387 
14391  bool ShowInverse(MatrixKit & out_matrix) const;
14392 
14397  bool ShowAdjoint(MatrixKit & out_matrix) const;
14398 
14399 
14405  MatrixKit & Rotate(float in_x, float in_y, float in_z);
14406 
14411  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
14412 
14418  MatrixKit & Translate(float in_x, float in_y, float in_z);
14419 
14425  MatrixKit & Scale(float in_x, float in_y, float in_z);
14426 
14430  MatrixKit & Concatenate(MatrixKit const & in_kit);
14431 
14434  MatrixKit & Normalize();
14435 
14438  MatrixKit & Invert();
14439 
14443  MatrixKit & Adjoint();
14444 
14445 
14449  MatrixKit Multiply(MatrixKit const & in_right) const;
14450 
14454  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14455 
14459  MatrixKit Multiply(float in_scalar) const;
14460 
14464  MatrixKit const & MultiplyAndAssign(float in_scalar);
14465 
14469  MatrixKit operator*(MatrixKit const & in_right) const;
14470 
14474  MatrixKit const & operator*=(MatrixKit const & in_right);
14475 
14479  MatrixKit operator*(float in_scalar) const;
14480 
14484  MatrixKit const & operator*=(float in_scalar);
14485 
14486 
14490  Point Transform(Point const & in_source) const;
14491 
14495  PointArray Transform(PointArray const & in_source) const;
14496 
14501  PointArray Transform(size_t in_count, Point const in_source []) const;
14502 
14506  Vector Transform(Vector const & in_source) const;
14507 
14511  VectorArray Transform(VectorArray const & in_source) const;
14512 
14517  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14518 
14522  Plane Transform(Plane const & in_source) const;
14523 
14527  PlaneArray Transform(PlaneArray const & in_source) const;
14528 
14533  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14534 
14538  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
14539 
14543  SimpleSphere Transform(SimpleSphere const & in_source) const;
14544 };
14545 
14549 class HPS_API ModellingMatrixControl : public Control
14550 {
14551 public:
14552 
14554  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14555 
14557  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14558 
14561 
14566 
14570  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14571 
14574 
14575  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
14576 
14578  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14579 
14585  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14586 
14591  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14592 
14596  ModellingMatrixControl & SetElements(FloatArray const & in_matrix);
14597 
14602  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14603 
14604 
14607  ModellingMatrixControl & UnsetEverything();
14608 
14609 
14615  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14616 
14621  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14622 
14626  bool ShowElements(FloatArray & out_matrix) const;
14627 
14631  bool ShowDeterminant(float & out_determinant) const;
14632 
14636  bool ShowInverse(MatrixKit & out_matrix) const;
14637 
14642  bool ShowAdjoint(MatrixKit & out_matrix) const;
14643 
14649  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14650 
14655  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14656 
14662  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14663 
14669  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14670 
14674  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14675 
14678  ModellingMatrixControl & Normalize();
14679 
14682  ModellingMatrixControl & Invert();
14683 
14687  ModellingMatrixControl & Adjoint();
14688 
14689 private:
14692 };
14693 
14696 class HPS_API TextureMatrixControl : public Control
14697 {
14698 public:
14699 
14701  explicit TextureMatrixControl(SegmentKey & in_seg);
14702 
14704  TextureMatrixControl(const TextureMatrixControl & in_that);
14705 
14710 
14714  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14715 
14718 
14719  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
14720 
14722  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14723 
14724 
14730  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14731 
14736  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14737 
14741  TextureMatrixControl & SetElements(FloatArray const & in_matrix);
14742 
14747  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14748 
14749 
14752  TextureMatrixControl & UnsetEverything();
14753 
14754 
14760  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14761 
14766  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14767 
14771  bool ShowElements(FloatArray & out_matrix) const;
14772 
14776  bool ShowDeterminant(float & out_determinant) const;
14777 
14781  bool ShowInverse(MatrixKit & out_matrix) const;
14782 
14787  bool ShowAdjoint(MatrixKit & out_matrix) const;
14788 
14794  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14795 
14800  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14801 
14807  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
14808 
14814  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
14815 
14819  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
14820 
14823  TextureMatrixControl & Normalize();
14824 
14827  TextureMatrixControl & Invert();
14828 
14832  TextureMatrixControl & Adjoint();
14833 
14834 private:
14837 };
14838 
14839 
14842 class HPS_API MaterialMappingKit : public Object
14843 {
14844 public:
14845 
14848 
14851  MaterialMappingKit(MaterialMappingKit const & in_kit);
14852 
14857 
14861  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
14862 
14864  ~MaterialMappingKit();
14865 
14866  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
14867 
14871  static MaterialMappingKit GetDefault();
14872 
14875  void Set(MaterialMappingKit const & in_kit);
14876 
14879  void Show(MaterialMappingKit & out_kit) const;
14880 
14884  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
14885 
14888  bool Empty() const;
14889 
14893  bool Equals(MaterialMappingKit const & in_kit) const;
14894 
14898  bool operator==(MaterialMappingKit const & in_kit) const;
14899 
14903  bool operator!=(MaterialMappingKit const & in_kit) const;
14904 
14905  //Set
14906 
14910  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
14911 
14917  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
14918 
14919 
14923  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
14924 
14930  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
14931 
14937  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14938 
14943  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
14944 
14951  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14952 
14961  MaterialMappingKit & SetBackFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14962 
14966  MaterialMappingKit & SetBackFaceGloss(float in_value);
14967 
14971  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
14972 
14977  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
14978 
14984  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14985 
14990  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
14991 
14998  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14999 
15008  MaterialMappingKit & SetFrontFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15009 
15013  MaterialMappingKit & SetFrontFaceGloss(float in_value);
15014 
15018  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
15019 
15024  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
15025 
15026 
15030  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15031 
15037  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
15038 
15044  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15045 
15050  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
15051 
15058  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15059 
15068  MaterialMappingKit & SetCutFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15069 
15073  MaterialMappingKit & SetCutFaceGloss(float in_value);
15074 
15078  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
15079 
15084  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
15085 
15090  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
15091 
15097  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15098 
15105  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15106 
15115  MaterialMappingKit & SetEdgeModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15116 
15120  MaterialMappingKit & SetEdgeGloss(float in_value);
15121 
15125  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
15126 
15131  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
15132 
15137  MaterialMappingKit & SetFaceAlpha(float in_alpha);
15138 
15144  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15145 
15152  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15153 
15162  MaterialMappingKit & SetFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15163 
15167  MaterialMappingKit & SetFaceGloss(float in_value);
15168 
15172  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
15173 
15178  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
15179 
15183  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
15184 
15185 
15186 
15187 
15188 
15192  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
15193 
15199  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
15200 
15201 
15205  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
15206 
15212  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
15213 
15214 
15218  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
15219 
15225  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
15226 
15227 
15231  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
15232 
15238  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
15239 
15244  MaterialMappingKit & SetVertexAlpha(float in_alpha);
15245 
15251  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15252 
15259  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15260 
15269  MaterialMappingKit & SetVertexModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15270 
15274  MaterialMappingKit & SetVertexGloss(float in_value);
15275 
15279  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
15280 
15285  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
15286 
15290  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
15291 
15292 
15296  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
15297 
15303  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
15304 
15305 
15309  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15310 
15316  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
15317 
15318  //Aggregate Sets
15319 
15323  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15324 
15329  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
15330 
15331 
15335  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15336 
15342  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
15343 
15344 
15345  //Unset
15346 
15349  MaterialMappingKit & UnsetAmbientLightUpColor();
15350 
15351 
15354  MaterialMappingKit & UnsetAmbientLightDownColor();
15355 
15356 
15359  MaterialMappingKit & UnsetBackFaceMaterial();
15360 
15363  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
15364 
15367  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15368 
15371  MaterialMappingKit & UnsetFrontFaceMaterial();
15372 
15375  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
15376 
15379  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15380 
15381 
15382 
15385  MaterialMappingKit & UnsetCutEdgeColor();
15386 
15387 
15390  MaterialMappingKit & UnsetCutFaceMaterial();
15391 
15394  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
15395 
15398  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15399 
15400 
15403  MaterialMappingKit & UnsetEdgeMaterial();
15404 
15407  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
15408 
15411  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15412 
15413 
15416  MaterialMappingKit & UnsetFaceMaterial();
15417 
15420  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
15421 
15424  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15425 
15426 
15429  MaterialMappingKit & UnsetLightColor();
15430 
15431 
15434  MaterialMappingKit & UnsetLineColor();
15435 
15436 
15439  MaterialMappingKit & UnsetMarkerColor();
15440 
15441 
15444  MaterialMappingKit & UnsetTextColor();
15445 
15446 
15449  MaterialMappingKit & UnsetVertexMaterial();
15450 
15453  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15454 
15457  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15458 
15459 
15462  MaterialMappingKit & UnsetWindowColor();
15463 
15464 
15467  MaterialMappingKit & UnsetWindowContrastColor();
15468 
15469 
15470  //Aggregate Unsets
15471 
15474  MaterialMappingKit & UnsetCutGeometryColor();
15475 
15478  MaterialMappingKit & UnsetAmbientLightColor();
15479 
15482  MaterialMappingKit & UnsetEverything();
15483 
15484 
15485  //Show
15486 
15492  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15493 
15499  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15500 
15501 
15509  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15510 
15519  bool ShowBackFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15520 
15526  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15527 
15528 
15536  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15537 
15546  bool ShowFrontFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15547 
15553  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15554 
15555 
15556 
15562  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15563 
15564 
15572  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15573 
15582  bool ShowCutFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15583 
15589  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15590 
15591 
15599  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15600 
15609  bool ShowEdgeChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15610 
15616  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15617 
15618 
15626  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15627 
15636  bool ShowFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15637 
15643  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15644 
15645 
15651  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15652 
15653 
15659  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15660 
15661 
15667  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15668 
15669 
15675  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15676 
15677 
15685  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15686 
15695  bool ShowVertexChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15696 
15702  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15703 
15704 
15710  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15711 
15712 
15718  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15719 };
15720 
15721 
15727 class HPS_API MaterialMappingControl : public Control
15728 {
15729 public:
15730 
15732  explicit MaterialMappingControl(SegmentKey & in_seg);
15733 
15736 
15741 
15745  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15746 
15749 
15750  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
15751 
15753  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15754 
15755  //Set
15756 
15760  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15761 
15767  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15768 
15769 
15773  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15774 
15780  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15781 
15786  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15787 
15793  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15794 
15801  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15802 
15811  MaterialMappingControl & SetBackFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15812 
15816  MaterialMappingControl & SetBackFaceGloss(float in_value);
15817 
15821  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
15822 
15827  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
15828 
15829 
15834  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
15835 
15841  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15842 
15849  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15850 
15859  MaterialMappingControl & SetFrontFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15860 
15864  MaterialMappingControl & SetFrontFaceGloss(float in_value);
15865 
15869  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
15870 
15875  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
15876 
15877 
15881  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15882 
15888  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
15889 
15894  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
15895 
15901  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15902 
15909  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15910 
15919  MaterialMappingControl & SetCutFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15920 
15924  MaterialMappingControl & SetCutFaceGloss(float in_value);
15925 
15929  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
15930 
15935  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
15936 
15941  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
15942 
15948  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15949 
15956  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15957 
15966  MaterialMappingControl & SetEdgeModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15967 
15971  MaterialMappingControl & SetEdgeGloss(float in_value);
15972 
15976  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
15977 
15982  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
15983 
15989  MaterialMappingControl & SetFaceAlpha(float in_alpha);
15990 
15997  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15998 
16005  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16006 
16015  MaterialMappingControl & SetFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16016 
16020  MaterialMappingControl & SetFaceGloss(float in_value);
16021 
16025  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
16026 
16031  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
16032 
16036  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
16037 
16038 
16042  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
16043 
16049  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
16050 
16051 
16055  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
16056 
16062  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
16063 
16064 
16068  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
16069 
16075  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
16076 
16077 
16081  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
16082 
16088  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
16089 
16090 
16095  MaterialMappingControl & SetVertexAlpha(float in_alpha);
16096 
16097 
16103  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16104 
16111  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16112 
16121  MaterialMappingControl & SetVertexModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16122 
16126  MaterialMappingControl & SetVertexGloss(float in_value);
16127 
16131  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
16132 
16137  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
16138 
16142  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
16143 
16144 
16148  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
16149 
16155  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
16156 
16157 
16161  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16162 
16168  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
16169 
16170  //Aggregate Sets
16171 
16175  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16176 
16181  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
16182 
16183 
16187  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16188 
16194  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
16195 
16196 
16197  //Unset
16198 
16201  MaterialMappingControl & UnsetAmbientLightUpColor();
16202 
16203 
16206  MaterialMappingControl & UnsetAmbientLightDownColor();
16207 
16208 
16211  MaterialMappingControl & UnsetFrontFaceMaterial();
16212 
16215  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
16216 
16219  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16220 
16221 
16224  MaterialMappingControl & UnsetBackFaceMaterial();
16225 
16228  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
16229 
16232  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16233 
16234 
16237  MaterialMappingControl & UnsetCutEdgeColor();
16238 
16239 
16242  MaterialMappingControl & UnsetCutFaceMaterial();
16243 
16246  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
16247 
16250  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16251 
16252 
16255  MaterialMappingControl & UnsetEdgeMaterial();
16256 
16259  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
16260 
16263  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16264 
16265 
16268  MaterialMappingControl & UnsetFaceMaterial();
16269 
16272  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
16273 
16276  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16277 
16278 
16281  MaterialMappingControl & UnsetLightColor();
16282 
16283 
16286  MaterialMappingControl & UnsetLineColor();
16287 
16288 
16291  MaterialMappingControl & UnsetMarkerColor();
16292 
16293 
16296  MaterialMappingControl & UnsetTextColor();
16297 
16298 
16301  MaterialMappingControl & UnsetVertexMaterial();
16302 
16305  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
16306 
16309  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16310 
16311 
16314  MaterialMappingControl & UnsetWindowColor();
16315 
16316 
16319  MaterialMappingControl & UnsetWindowContrastColor();
16320 
16321 
16322  //Aggregate Unsets
16323 
16326  MaterialMappingControl & UnsetCutGeometryColor();
16327 
16330  MaterialMappingControl & UnsetAmbientLightColor();
16331 
16334  MaterialMappingControl & UnsetEverything();
16335 
16336 
16337  //Show
16338 
16344  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16345 
16346 
16352  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16353 
16354 
16362  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16363 
16372  bool ShowBackFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16373 
16379  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16380 
16381 
16389  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16390 
16399  bool ShowFrontFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16400 
16406  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16407 
16408 
16414  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16415 
16416 
16424  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16425 
16434  bool ShowCutFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16435 
16441  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16442 
16443 
16451  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16452 
16461  bool ShowEdgeChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16462 
16468  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16469 
16470 
16478  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16479 
16488  bool ShowFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16489 
16495  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16496 
16497 
16503  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16504 
16505 
16511  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16512 
16513 
16519  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16520 
16521 
16527  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16528 
16529 
16537  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16538 
16547  bool ShowVertexChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16548 
16554  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16555 
16556 
16562  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16563 
16564 
16570  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16571 
16572 private:
16574 };
16575 
16576 
16579 class HPS_API PortfolioControl : public Control
16580 {
16581 public:
16583  explicit PortfolioControl(SegmentKey & in_seg);
16584 
16586  PortfolioControl(PortfolioControl const & in_that);
16587 
16591  PortfolioControl(PortfolioControl && in_that);
16592 
16596  PortfolioControl & operator=(PortfolioControl && in_that);
16597 
16599  ~PortfolioControl();
16600 
16601  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
16602 
16604  PortfolioControl & operator=(PortfolioControl const & in_that);
16605 
16607  size_t GetCount() const;
16608 
16609 
16614  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16615 
16618  bool Pop();
16619 
16623  bool Pop(PortfolioKey & out_portfolio);
16624 
16625 
16629  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16630 
16634  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16635 
16640  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16641 
16642 
16645  PortfolioControl & UnsetTop();
16646 
16649  PortfolioControl & UnsetEverything();
16650 
16651 
16655  bool ShowTop(PortfolioKey & out_portfolio) const;
16656 
16660  bool Show(PortfolioKeyArray & out_portfolios) const;
16661 
16662 private:
16663  PortfolioControl();
16664 };
16665 
16666 
16667 
16670 class HPS_API StyleControl : public Control
16671 {
16672 public:
16674  explicit StyleControl(SegmentKey & in_seg);
16675 
16677  StyleControl(StyleControl const & in_that);
16678 
16682  StyleControl(StyleControl && in_that);
16683 
16687  StyleControl & operator=(StyleControl && in_that);
16688 
16690  ~StyleControl();
16691 
16692  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
16693 
16695  StyleControl & operator=(StyleControl const & in_that);
16696 
16698  size_t GetCount() const;
16699 
16700 
16702  StyleKey PushNamed(char const * in_style_name);
16703 
16705  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16706 
16708  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16709 
16713  StyleKey PushSegment(SegmentKey const & in_style_source);
16714 
16718  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16719 
16722  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16723 
16724 
16725 
16728  bool Pop();
16729 
16736  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16737 
16741  void Flush(SegmentKey const & in_style_source);
16742 
16749  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16750 
16754  void Flush(char const * in_style_name);
16755 
16762  void Flush(char const * in_style_name, Condition const & in_condition);
16763 
16764 
16767  StyleKey SetNamed(char const * in_style_name);
16768 
16772  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16773 
16774 
16777  StyleKey SetSegment(SegmentKey const & in_style_source);
16778 
16782  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16783 
16784 
16790  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16791 
16796  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16797 
16804  void Set(size_t in_count, Style::Type const in_types[], SegmentKey const in_segment_sources[], UTF8 const in_style_names[], Condition const in_conditions[]);
16805 
16806 
16807 
16809  void UnsetTop();
16810 
16812  void UnsetAllSegment();
16813 
16815  void UnsetAllNamed();
16816 
16818  void UnsetEverything();
16819 
16820 
16827  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
16828 
16832  bool ShowTop(StyleKey & out_style) const;
16833 
16840  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
16841 
16845  bool Show(StyleKeyArray & out_styles) const;
16846 
16851  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions) const;
16852 
16856  bool ShowAllSegment(StyleKeyArray & out_styles) const;
16857 
16862  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions) const;
16863 
16867  bool ShowAllNamed(StyleKeyArray & out_styles) const;
16868 
16869 private:
16870  StyleControl();
16871 };
16872 
16873 
16876 class HPS_API ConditionControl : public Control
16877 {
16878 public:
16880  explicit ConditionControl(SegmentKey & in_seg);
16881 
16883  ConditionControl(ConditionControl const & in_that);
16884 
16888  ConditionControl(ConditionControl && in_that);
16889 
16893  ConditionControl & operator=(ConditionControl && in_that);
16894 
16896  ~ConditionControl();
16897 
16898 
16899  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
16900 
16902  ConditionControl & operator=(ConditionControl const & in_that);
16903 
16906  size_t GetCount() const;
16907 
16911  ConditionControl & AddCondition(char const * in_condition);
16912 
16913 
16917  ConditionControl & SetCondition(char const * in_condition);
16918 
16922  ConditionControl & SetConditions(UTF8Array const & in_conditions);
16923 
16928  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
16929 
16930 
16934  ConditionControl & UnsetCondition(char const * in_condition);
16935 
16938  ConditionControl & UnsetEverything();
16939 
16940 
16944  bool ShowCondition(char const * in_condition) const;
16945 
16949  bool ShowConditions(UTF8Array & out_conditions) const;
16950 
16951 private:
16953  ConditionControl();
16954 };
16955 
16956 
16959 class HPS_API MaterialKit : public Object
16960 {
16961 public:
16962 
16964  MaterialKit();
16965 
16968  MaterialKit(MaterialKit const & in_kit);
16969 
16973  MaterialKit(MaterialKit && in_that);
16974 
16978  MaterialKit & operator=(MaterialKit && in_that);
16979 
16981  ~MaterialKit();
16982 
16983  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
16984 
16987  void Set(MaterialKit const & in_kit);
16988 
16991  void Show(MaterialKit & out_kit) const;
16992 
16996  MaterialKit & operator=(MaterialKit const & in_kit);
16997 
17000  bool Empty() const;
17001 
17005  bool Equals(MaterialKit const & in_kit) const;
17006 
17010  bool operator==(MaterialKit const & in_kit) const;
17011 
17015  bool operator!=(MaterialKit const & in_kit) const;
17016 
17017 
17018  //Set
17019 
17023  MaterialKit & SetDiffuse(RGBColor const & in_color);
17024 
17028  MaterialKit & SetDiffuse(RGBAColor const & in_color);
17029 
17033  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
17034 
17038  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
17039 
17044  MaterialKit & SetDiffuseAlpha(float in_alpha);
17045 
17052  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
17053 
17061  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
17062 
17067  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
17068 
17074  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
17075 
17082  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
17083 
17091  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
17092 
17093 
17097  MaterialKit & SetShader(char const * in_shader_name);
17098 
17099 
17100 
17104  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
17105 
17109  MaterialKit & SetSpecular(char const * in_texture_name);
17110 
17115  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
17116 
17117 
17118 
17122  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
17123 
17127  MaterialKit & SetMirror(char const * in_texture_name);
17128 
17133  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
17134 
17135 
17136 
17140  MaterialKit & SetTransmission(char const * in_texture_name);
17141 
17146  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17147 
17148 
17149 
17153  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
17154 
17158  MaterialKit & SetEmission(char const * in_texture_name);
17159 
17164  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
17165 
17166 
17167 
17171  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
17172 
17177  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
17178 
17182  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
17183 
17188  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
17189 
17192  MaterialKit & SetEnvironmentTexture();
17193 
17194 
17198  MaterialKit & SetBump(char const * in_texture_name);
17199 
17200 
17201 
17208  MaterialKit & SetGloss(float in_gloss);
17209 
17212  MaterialKit & UnsetDiffuseColorRGB();
17213 
17216  MaterialKit & UnsetDiffuseColor();
17217 
17220  MaterialKit & UnsetDiffuseAlpha();
17221 
17224  MaterialKit & UnsetDiffuseTexture();
17225 
17229  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
17230 
17233  MaterialKit & UnsetShader();
17234 
17237  MaterialKit & UnsetSpecular();
17238 
17241  MaterialKit & UnsetMirror();
17242 
17245  MaterialKit & UnsetTransmission();
17246 
17249  MaterialKit & UnsetEmission();
17250 
17253  MaterialKit & UnsetEnvironment();
17254 
17257  MaterialKit & UnsetBump();
17258 
17261  MaterialKit & UnsetGloss();
17262 
17265  MaterialKit & UnsetEverything();
17266 
17267 
17270  bool ShowDiffuse() const;
17271 
17275  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
17276 
17280  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
17281 
17285  bool ShowDiffuseAlpha(float & out_alpha) const;
17286 
17293  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17294 
17302  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17303 
17310  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
17311 
17315  bool ShowShader(UTF8 & out_shader_name) const;
17316 
17325  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17326 
17335  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17336 
17337 
17338 
17347  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17348 
17349 
17358  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17359 
17360 
17369  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
17370 
17371 
17375  bool ShowBump(UTF8 & out_texture_name) const;
17376 
17381  bool ShowGloss(float & out_gloss) const;
17382 };
17383 
17384 
17386 class HPS_API NURBSSurfaceAttributeKit : public Object
17387 {
17388 public:
17389 
17392 
17396 
17401 
17405  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
17406 
17408  virtual ~NURBSSurfaceAttributeKit();
17409 
17410  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
17411 
17415  static NURBSSurfaceAttributeKit GetDefault();
17416 
17419  void Set(NURBSSurfaceAttributeKit const & in_kit);
17420 
17423  void Show(NURBSSurfaceAttributeKit & out_kit) const;
17424 
17428  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17429 
17432  bool Empty() const;
17433 
17437  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17438 
17442  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17443 
17447  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17448 
17449 
17453  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17454 
17459  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17460 
17464  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17465 
17469  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17470 
17474  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17475 
17480  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17481 
17482 
17485  NURBSSurfaceAttributeKit & UnsetBudget();
17486 
17489  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17490 
17493  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17494 
17497  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17498 
17501  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17502 
17505  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17506 
17509  NURBSSurfaceAttributeKit & UnsetEverything();
17510 
17514  bool ShowBudget(size_t & out_budget) const;
17515 
17519  bool ShowMaximumDeviation(float & out_deviation) const;
17520 
17524  bool ShowMaximumAngle(float & out_degrees) const;
17525 
17529  bool ShowMaximumWidth(float & out_width) const;
17530 
17534  bool ShowTrimBudget(size_t & out_budget) const;
17535 
17539  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17540 };
17541 
17548 {
17549 public:
17550 
17552  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17553 
17556 
17561 
17566 
17569 
17570  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
17571 
17573  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17574 
17578  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17579 
17584  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17585 
17589  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17590 
17594  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17595 
17599  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17600 
17605  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17606 
17607 
17610  NURBSSurfaceAttributeControl & UnsetBudget();
17611 
17614  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17615 
17618  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17619 
17622  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17623 
17626  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17627 
17630  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17631 
17634  NURBSSurfaceAttributeControl & UnsetEverything();
17635 
17636 
17640  bool ShowBudget(size_t & out_budget) const;
17641 
17645  bool ShowMaximumDeviation(float & out_deviation) const;
17646 
17650  bool ShowMaximumAngle(float & out_degrees) const;
17651 
17655  bool ShowMaximumWidth(float & out_width) const;
17656 
17660  bool ShowTrimBudget(size_t & out_budget) const;
17661 
17665  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17666 
17667 private:
17670 };
17671 
17672 
17673 
17675 class HPS_API PerformanceKit : public Object
17676 {
17677 public:
17678 
17680  PerformanceKit();
17681 
17684  PerformanceKit(PerformanceKit const & in_kit);
17685 
17689  PerformanceKit(PerformanceKit && in_that);
17690 
17694  PerformanceKit & operator=(PerformanceKit && in_that);
17695 
17697  virtual ~PerformanceKit();
17698 
17699  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
17700 
17704  static PerformanceKit GetDefault();
17705 
17708  void Set(PerformanceKit const & in_kit);
17709 
17712  void Show(PerformanceKit & out_kit) const;
17713 
17717  PerformanceKit & operator=(PerformanceKit const & in_kit);
17718 
17721  bool Empty() const;
17722 
17726  bool Equals(PerformanceKit const & in_kit) const;
17727 
17731  bool operator==(PerformanceKit const & in_kit) const;
17732 
17736  bool operator!=(PerformanceKit const & in_kit) const;
17737 
17738 
17743 
17748  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17749 
17750 
17753  PerformanceKit & UnsetDisplayLists();
17754 
17757  PerformanceKit & UnsetStaticModel();
17758 
17761  PerformanceKit & UnsetEverything();
17762 
17766  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17767 
17771  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17772 };
17773 
17774 
17780 class HPS_API PerformanceControl : public Control
17781 {
17782 public:
17783 
17785  explicit PerformanceControl(SegmentKey & in_seg);
17786 
17788  PerformanceControl(PerformanceControl const & in_that);
17789 
17794 
17798  PerformanceControl & operator=(PerformanceControl && in_that);
17799 
17801  ~PerformanceControl();
17802 
17803  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
17804 
17806  PerformanceControl & operator=(PerformanceControl const & in_that);
17807 
17808 
17813 
17818  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
17819 
17820 
17823  PerformanceControl & UnsetDisplayLists();
17824 
17827  PerformanceControl & UnsetStaticModel();
17828 
17831  PerformanceControl & UnsetEverything();
17832 
17833 
17837  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17838 
17842  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17843 
17844 private:
17847 };
17848 
17849 
17850 
17852 class HPS_API HiddenLineAttributeKit : public Object
17853 {
17854 public:
17855 
17858 
17862 
17867 
17871  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
17872 
17874  virtual ~HiddenLineAttributeKit();
17875 
17876  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
17877 
17881  static HiddenLineAttributeKit GetDefault();
17882 
17885  void Set(HiddenLineAttributeKit const & in_kit);
17886 
17889  void Show(HiddenLineAttributeKit & out_kit) const;
17890 
17894  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
17895 
17898  bool Empty() const;
17899 
17903  bool Equals(HiddenLineAttributeKit const & in_kit) const;
17904 
17908  bool operator==(HiddenLineAttributeKit const & in_kit) const;
17909 
17913  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
17914 
17915 
17919  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
17920 
17926  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
17927 
17937  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
17938 
17942  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
17943 
17947  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
17948 
17952  HiddenLineAttributeKit & SetRenderText(bool in_state);
17953 
17958  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
17959 
17965  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
17966 
17970  HiddenLineAttributeKit & SetVisibility(bool in_state);
17971 
17976  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
17977 
17983  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
17984 
17985 
17988  HiddenLineAttributeKit & UnsetColor();
17989 
17992  HiddenLineAttributeKit & UnsetDimFactor();
17993 
17996  HiddenLineAttributeKit & UnsetFaceDisplacement();
17997 
18000  HiddenLineAttributeKit & UnsetLinePattern();
18001 
18004  HiddenLineAttributeKit & UnsetRenderFaces();
18005 
18008  HiddenLineAttributeKit & UnsetRenderText();
18009 
18012  HiddenLineAttributeKit & UnsetAlgorithm();
18013 
18016  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
18017 
18020  HiddenLineAttributeKit & UnsetVisibility();
18021 
18024  HiddenLineAttributeKit & UnsetWeight();
18025 
18028  HiddenLineAttributeKit & UnsetTransparencyCutoff();
18029 
18032  HiddenLineAttributeKit & UnsetEverything();
18033 
18034 
18038  bool ShowColor(RGBAColor & out_color) const;
18039 
18043  bool ShowDimFactor(float & out_zero_to_one) const;
18044 
18048  bool ShowFaceDisplacement(float & out_buckets) const;
18049 
18053  bool ShowLinePattern(UTF8 & out_pattern) const;
18054 
18058  bool ShowRenderFaces(bool & out_state) const;
18059 
18063  bool ShowRenderText(bool & out_state) const;
18064 
18068  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18069 
18073  bool ShowSilhouetteCleanup(bool & out_state) const;
18074 
18078  bool ShowVisibility(bool & out_state) const;
18079 
18084  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18085 
18089  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18090 };
18091 
18092 
18098 class HPS_API HiddenLineAttributeControl : public Control
18099 {
18100 public:
18101 
18103  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
18104 
18107 
18112 
18117 
18120 
18121  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
18122 
18124  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
18125 
18129  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
18130 
18136  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
18137 
18147  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
18148 
18152  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
18153 
18157  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
18158 
18162  HiddenLineAttributeControl & SetRenderText(bool in_state);
18163 
18168  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
18169 
18175  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
18176 
18180  HiddenLineAttributeControl & SetVisibility(bool in_state);
18181 
18186  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
18187 
18193  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
18194 
18195 
18198  HiddenLineAttributeControl & UnsetColor();
18199 
18202  HiddenLineAttributeControl & UnsetDimFactor();
18203 
18206  HiddenLineAttributeControl & UnsetFaceDisplacement();
18207 
18210  HiddenLineAttributeControl & UnsetLinePattern();
18211 
18214  HiddenLineAttributeControl & UnsetRenderFaces();
18215 
18218  HiddenLineAttributeControl & UnsetRenderText();
18219 
18222  HiddenLineAttributeControl & UnsetAlgorithm();
18223 
18226  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
18227 
18230  HiddenLineAttributeControl & UnsetVisibility();
18231 
18234  HiddenLineAttributeControl & UnsetWeight();
18235 
18238  HiddenLineAttributeControl & UnsetTransparencyCutoff();
18239 
18242  HiddenLineAttributeControl & UnsetEverything();
18243 
18244 
18248  bool ShowColor(RGBAColor & out_color) const;
18249 
18253  bool ShowDimFactor(float & out_zero_to_one) const;
18254 
18258  bool ShowFaceDisplacement(float & out_buckets) const;
18259 
18263  bool ShowLinePattern(UTF8 & out_pattern) const;
18264 
18268  bool ShowRenderFaces(bool & out_state) const;
18269 
18273  bool ShowRenderText(bool & out_state) const;
18274 
18278  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
18279 
18283  bool ShowSilhouetteCleanup(bool & out_state) const;
18284 
18288  bool ShowVisibility(bool & out_state) const;
18289 
18294  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
18295 
18299  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
18300 
18301 private:
18304 };
18305 
18306 
18307 
18309 class HPS_API DrawingAttributeKit : public Object
18310 {
18311 public:
18312 
18315 
18318  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
18319 
18324 
18328  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
18329 
18331  virtual ~DrawingAttributeKit();
18332 
18333  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
18334 
18338  static DrawingAttributeKit GetDefault();
18339 
18342  void Set(DrawingAttributeKit const & in_kit);
18343 
18346  void Show(DrawingAttributeKit & out_kit) const;
18347 
18351  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
18352 
18355  bool Empty() const;
18356 
18360  bool Equals(DrawingAttributeKit const & in_kit) const;
18361 
18365  bool operator==(DrawingAttributeKit const & in_kit) const;
18366 
18370  bool operator!=(DrawingAttributeKit const & in_kit) const;
18371 
18387  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
18388 
18394  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
18395 
18408  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
18409 
18416  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
18417 
18422  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
18423 
18430  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18431 
18436  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18437 
18444  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18445 
18450  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18451 
18455  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18456 
18461  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18462 
18468  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18469 
18476  DrawingAttributeKit & SetClipRegion(size_t in_number_of_points, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18477 
18483  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18484 
18487  DrawingAttributeKit & UnsetPolygonHandedness();
18488 
18491  DrawingAttributeKit & UnsetWorldHandedness();
18492 
18495  DrawingAttributeKit & UnsetDepthRange();
18496 
18499  DrawingAttributeKit & UnsetFaceDisplacement();
18500 
18503  DrawingAttributeKit & UnsetGeneralDisplacement();
18504 
18507  DrawingAttributeKit & UnsetVertexDisplacement();
18508 
18511  DrawingAttributeKit & UnsetOverlay();
18512 
18515  DrawingAttributeKit & UnsetDeferral();
18516 
18519  DrawingAttributeKit & UnsetClipRegion();
18520 
18523  DrawingAttributeKit & UnsetEverything();
18524 
18528  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18529 
18533  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18534 
18539  bool ShowDepthRange(float & out_near, float & out_far) const;
18540 
18545  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18546 
18551  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18552 
18557  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18558 
18562  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18563 
18567  bool ShowDeferral(int & out_defer_batch) const;
18568 
18574  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18575 
18576 };
18577 
18578 
18590 class HPS_API DrawingAttributeControl : public Control
18591 {
18592 public:
18593 
18595  explicit DrawingAttributeControl(SegmentKey & in_seg);
18596 
18599 
18604 
18608  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18609 
18612 
18613  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
18614 
18616  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18617 
18627  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18628 
18634  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18635 
18648  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18649 
18656  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18657 
18662  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18663 
18670  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18671 
18676  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18677 
18684  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18685 
18690  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18691 
18695  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18696 
18702  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18703 
18710  DrawingAttributeControl & SetClipRegion(size_t in_number_of_points, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18711 
18717  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18718 
18723  DrawingAttributeControl & SetDeferral(int in_deferral);
18726  DrawingAttributeControl & UnsetPolygonHandedness();
18727 
18730  DrawingAttributeControl & UnsetWorldHandedness();
18731 
18734  DrawingAttributeControl & UnsetDepthRange();
18735 
18738  DrawingAttributeControl & UnsetFaceDisplacement();
18739 
18742  DrawingAttributeControl & UnsetGeneralDisplacement();
18743 
18746  DrawingAttributeControl & UnsetVertexDisplacement();
18747 
18750  DrawingAttributeControl & UnsetOverlay();
18751 
18754  DrawingAttributeControl & UnsetDeferral();
18755 
18758  DrawingAttributeControl & UnsetClipRegion();
18759 
18762  DrawingAttributeControl & UnsetEverything();
18763 
18764 
18768  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18769 
18773  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18774 
18779  bool ShowDepthRange(float & out_x, float & out_y) const;
18780 
18785  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18786 
18791  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18792 
18797  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18798 
18802  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18803 
18807  bool ShowDeferral(int & out_defer_batch) const;
18808 
18814  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation);
18815 
18816 private:
18819 };
18820 
18821 
18823 class HPS_API PostProcessEffectsKit : public Object
18824 {
18825 public:
18826 
18829 
18833 
18838 
18842  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
18843 
18845  virtual ~PostProcessEffectsKit();
18846 
18847  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
18848 
18852  static PostProcessEffectsKit GetDefault();
18853 
18856  void Set(PostProcessEffectsKit const & in_kit);
18857 
18860  void Show(PostProcessEffectsKit & out_kit) const;
18861 
18865  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
18866 
18869  bool Empty() const;
18870 
18874  bool Equals(PostProcessEffectsKit const & in_kit) const;
18875 
18879  bool operator==(PostProcessEffectsKit const & in_kit) const;
18880 
18884  bool operator!=(PostProcessEffectsKit const & in_kit) const;
18885 
18886 
18894  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18895 
18902  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18903 
18910  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18911 
18917  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
18918 
18925  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
18926 
18932  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
18933 
18941  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
18942 
18949  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
18950 
18958  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
18959 
18966  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
18967 
18970  PostProcessEffectsKit & UnsetAmbientOcclusion();
18971 
18974  PostProcessEffectsKit & UnsetBloom();
18975 
18978  PostProcessEffectsKit & UnsetDepthOfField();
18979 
18982  PostProcessEffectsKit & UnsetSilhouetteEdges();
18983 
18986  PostProcessEffectsKit & UnsetEyeDomeLighting();
18987 
18990  PostProcessEffectsKit & UnsetEverything();
18991 
18992 
18999  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19000 
19007  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19008 
19015  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19016 
19024  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19025 
19033  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19034 };
19035 
19036 
19040 class HPS_API PostProcessEffectsControl : public Control
19041 {
19042 public:
19043 
19045  explicit PostProcessEffectsControl(WindowKey & in_seg);
19046 
19049 
19054 
19058  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
19059 
19062 
19063  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
19064 
19066  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
19067 
19068 
19076  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
19077 
19084  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
19085 
19092  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
19093 
19099  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
19100 
19107  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
19108 
19114  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
19115 
19123  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
19124 
19131  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
19132 
19139  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
19140 
19147  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
19148 
19149 
19152  PostProcessEffectsControl & UnsetAmbientOcclusion();
19153 
19156  PostProcessEffectsControl & UnsetBloom();
19157 
19160  PostProcessEffectsControl & UnsetDepthOfField();
19161 
19164  PostProcessEffectsControl & UnsetSilhouetteEdges();
19165 
19168  PostProcessEffectsControl & UnsetEyeDomeLighting();
19169 
19172  PostProcessEffectsControl & UnsetEverything();
19173 
19174 
19181  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
19182 
19189  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
19190 
19197  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
19198 
19206  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
19207 
19215  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
19216 
19217 private:
19220 };
19221 
19223 class HPS_API TransformMaskKit : public Object
19224 {
19225 public:
19226 
19228  TransformMaskKit();
19229 
19231  TransformMaskKit(TransformMaskKit const & in_kit);
19232 
19236  TransformMaskKit(TransformMaskKit && in_that);
19237 
19241  TransformMaskKit & operator=(TransformMaskKit && in_that);
19242 
19244  virtual ~TransformMaskKit();
19245 
19246  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
19247 
19248  static TransformMaskKit GetDefault();
19249 
19251  void Set(TransformMaskKit const & in_kit);
19252 
19254  void Show(TransformMaskKit & out_kit) const;
19255 
19257  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
19258 
19260  bool Empty() const;
19261 
19263  bool Equals(TransformMaskKit const & in_kit) const;
19264 
19266  bool operator==(TransformMaskKit const & in_kit) const;
19267 
19269  bool operator!=(TransformMaskKit const & in_kit) const;
19270 
19271 
19275  TransformMaskKit & SetCameraRotation(bool in_state);
19276 
19280  TransformMaskKit & SetCameraScale(bool in_state);
19281 
19285  TransformMaskKit & SetCameraTranslation(bool in_state);
19286 
19290  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
19291 
19295  TransformMaskKit & SetCameraProjection(bool in_state);
19296 
19300  TransformMaskKit & SetCameraOffset(bool in_state);
19301 
19305  TransformMaskKit & SetCameraNearLimit(bool in_state);
19306 
19310  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
19311 
19315  TransformMaskKit & SetModellingMatrixScale(bool in_state);
19316 
19320  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
19321 
19325  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
19326 
19327 
19331  TransformMaskKit & SetCameraEverything(bool in_state);
19332 
19336  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
19337 
19341  TransformMaskKit & SetEverything(bool in_state);
19342 
19343 
19346  TransformMaskKit & UnsetCameraRotation();
19347 
19350  TransformMaskKit & UnsetCameraScale();
19351 
19354  TransformMaskKit & UnsetCameraTranslation();
19355 
19358  TransformMaskKit & UnsetCameraPerspectiveScale();
19359 
19362  TransformMaskKit & UnsetCameraProjection();
19363 
19366  TransformMaskKit & UnsetCameraOffset();
19367 
19370  TransformMaskKit & UnsetCameraNearLimit();
19371 
19374  TransformMaskKit & UnsetCameraEverything();
19375 
19378  TransformMaskKit & UnsetModellingMatrixRotation();
19379 
19382  TransformMaskKit & UnsetModellingMatrixScale();
19383 
19386  TransformMaskKit & UnsetModellingMatrixTranslation();
19387 
19390  TransformMaskKit & UnsetModellingMatrixOffset();
19391 
19394  TransformMaskKit & UnsetModellingMatrixEverything();
19395 
19398  TransformMaskKit & UnsetEverything();
19399 
19400 
19404  bool ShowCameraRotation(bool & out_state) const;
19405 
19409  bool ShowCameraScale(bool & out_state) const;
19410 
19414  bool ShowCameraTranslation(bool & out_state) const;
19415 
19419  bool ShowCameraPerspectiveScale(bool & out_state) const;
19420 
19424  bool ShowCameraProjection(bool & out_state) const;
19425 
19429  bool ShowCameraOffset(bool & out_state) const;
19430 
19434  bool ShowCameraNearLimit(bool & out_state) const;
19435 
19439  bool ShowModellingMatrixRotation(bool & out_state) const;
19440 
19444  bool ShowModellingMatrixScale(bool & out_state) const;
19445 
19449  bool ShowModellingMatrixTranslation(bool & out_state) const;
19450 
19454  bool ShowModellingMatrixOffset(bool & out_state) const;
19455 };
19456 
19457 
19462 class HPS_API TransformMaskControl : public Control
19463 {
19464 public:
19465 
19467  explicit TransformMaskControl(SegmentKey & in_seg);
19468 
19470  TransformMaskControl(TransformMaskControl const & in_that);
19471 
19476 
19480  TransformMaskControl & operator=(TransformMaskControl && in_that);
19481 
19484 
19485  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
19486 
19487 
19491  TransformMaskControl & SetCameraRotation(bool in_state);
19492 
19496  TransformMaskControl & SetCameraScale(bool in_state);
19497 
19501  TransformMaskControl & SetCameraTranslation(bool in_state);
19502 
19506  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19507 
19511  TransformMaskControl & SetCameraProjection(bool in_state);
19512 
19516  TransformMaskControl & SetCameraOffset(bool in_state);
19517 
19521  TransformMaskControl & SetCameraNearLimit(bool in_state);
19522 
19526  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19527 
19531  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19532 
19536  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19537 
19541  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19542 
19543 
19547  TransformMaskControl & SetCameraEverything(bool in_state);
19548 
19552  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19553 
19557  TransformMaskControl & SetEverything(bool in_state);
19558 
19559 
19562  TransformMaskControl & UnsetCameraRotation();
19563 
19566  TransformMaskControl & UnsetCameraScale();
19567 
19570  TransformMaskControl & UnsetCameraTranslation();
19571 
19574  TransformMaskControl & UnsetCameraPerspectiveScale();
19575 
19578  TransformMaskControl & UnsetCameraProjection();
19579 
19582  TransformMaskControl & UnsetCameraOffset();
19583 
19586  TransformMaskControl & UnsetCameraNearLimit();
19587 
19590  TransformMaskControl & UnsetCameraEverything();
19591 
19594  TransformMaskControl & UnsetModellingMatrixRotation();
19595 
19598  TransformMaskControl & UnsetModellingMatrixScale();
19599 
19602  TransformMaskControl & UnsetModellingMatrixTranslation();
19603 
19606  TransformMaskControl & UnsetModellingMatrixOffset();
19607 
19610  TransformMaskControl & UnsetModellingMatrixEverything();
19611 
19614  TransformMaskControl & UnsetEverything();
19615 
19616 
19620  bool ShowCameraRotation(bool & out_state) const;
19621 
19625  bool ShowCameraScale(bool & out_state) const;
19626 
19630  bool ShowCameraTranslation(bool & out_state) const;
19631 
19635  bool ShowCameraPerspectiveScale(bool & out_state) const;
19636 
19640  bool ShowCameraProjection(bool & out_state) const;
19641 
19645  bool ShowCameraOffset(bool & out_state) const;
19646 
19650  bool ShowCameraNearLimit(bool & out_state) const;
19651 
19655  bool ShowModellingMatrixRotation(bool & out_state) const;
19656 
19660  bool ShowModellingMatrixScale(bool & out_state) const;
19661 
19665  bool ShowModellingMatrixTranslation(bool & out_state) const;
19666 
19670  bool ShowModellingMatrixOffset(bool & out_state) const;
19671 
19672 private:
19675 };
19676 
19677 
19678 
19680 class HPS_API VisualEffectsKit : public Object
19681 {
19682 public:
19683 
19685  VisualEffectsKit();
19686 
19689  VisualEffectsKit(VisualEffectsKit const & in_kit);
19690 
19694  VisualEffectsKit(VisualEffectsKit && in_that);
19695 
19699  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19700 
19702  virtual ~VisualEffectsKit();
19703 
19704  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
19705 
19709  static VisualEffectsKit GetDefault();
19710 
19713  void Set(VisualEffectsKit const & in_kit);
19714 
19717  void Show(VisualEffectsKit & out_kit) const;
19718 
19722  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19723 
19726  bool Empty() const;
19727 
19731  bool Equals(VisualEffectsKit const & in_kit) const;
19732 
19736  bool operator==(VisualEffectsKit const & in_kit) const;
19737 
19741  bool operator!=(VisualEffectsKit const & in_kit) const;
19742 
19746  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19747 
19751  VisualEffectsKit & SetAntiAliasing(bool in_state);
19752 
19762  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19763 
19772  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19773 
19780  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19781 
19787  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19788 
19792  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19793 
19797  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19798 
19802  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19803 
19814  VisualEffectsKit & SetSimpleReflection(bool in_state, float in_opacity = 0.5f, unsigned int in_blurring = 1, bool in_fading = false, float in_attenuation_near_distance = 0.0f, float in_attenuation_far_distance = Float::Infinity);
19815 
19825  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19826 
19830  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19831 
19835  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19836 
19837 
19840  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
19841 
19844  VisualEffectsKit & UnsetAntiAliasing();
19845 
19848  VisualEffectsKit & UnsetShadowMaps();
19849 
19852  VisualEffectsKit & UnsetSimpleShadow();
19853 
19856  VisualEffectsKit & UnsetSimpleShadowPlane();
19857 
19860  VisualEffectsKit & UnsetSimpleShadowLightDirection();
19861 
19864  VisualEffectsKit & UnsetSimpleShadowColor();
19865 
19868  VisualEffectsKit & UnsetSimpleReflection();
19869 
19872  VisualEffectsKit & UnsetSimpleReflectionPlane();
19873 
19876  VisualEffectsKit & UnsetSimpleReflectionVisibility();
19877 
19880  VisualEffectsKit & UnsetEverything();
19881 
19885  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19886 
19890  bool ShowAntiAliasing(bool & out_state) const;
19891 
19899  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19900 
19907  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19908 
19912  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19913 
19917  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
19918 
19922  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
19923 
19932  bool ShowSimpleReflection(bool & out_state, float & out_opacity, unsigned int & out_blurring, bool & out_fading, float & out_attenuation_near_distance, float & out_attenuation_far_distance) const;
19933 
19934 
19938  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
19939 
19943  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
19944 };
19945 
19946 
19952 class HPS_API VisualEffectsControl : public Control
19953 {
19954 public:
19955 
19957  explicit VisualEffectsControl(SegmentKey & in_seg);
19958 
19960  VisualEffectsControl(VisualEffectsControl const & in_that);
19961 
19966 
19970  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
19971 
19974 
19975  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
19976 
19978  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
19979 
19983  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
19984 
19988  VisualEffectsControl & SetAntiAliasing(bool in_state);
19989 
19999  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
20000 
20009  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
20010 
20017  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
20018 
20024  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
20025 
20029  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20030 
20034  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
20035 
20039  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
20040 
20051  VisualEffectsControl & SetSimpleReflection(bool in_state, float in_opacity = 0.5f, unsigned int in_blurring = 1, bool in_fading = false, float in_attenuation_near_distance = 0.0f, float in_attenuation_far_distance = Float::Infinity);
20052 
20062  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
20063 
20067  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
20068 
20072  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
20073 
20074 
20077  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
20078 
20081  VisualEffectsControl & UnsetAntiAliasing();
20082 
20085  VisualEffectsControl & UnsetShadowMaps();
20086 
20089  VisualEffectsControl & UnsetSimpleShadow();
20090 
20093  VisualEffectsControl & UnsetSimpleShadowPlane();
20094 
20097  VisualEffectsControl & UnsetSimpleShadowLightDirection();
20098 
20101  VisualEffectsControl & UnsetSimpleShadowColor();
20102 
20105  VisualEffectsControl & UnsetSimpleReflection();
20106 
20109  VisualEffectsControl & UnsetSimpleReflectionPlane();
20110 
20113  VisualEffectsControl & UnsetSimpleReflectionVisibility();
20114 
20117  VisualEffectsControl & UnsetEverything();
20118 
20119 
20123  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
20124 
20128  bool ShowAntiAliasing(bool & out_state) const;
20129 
20137  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
20138 
20145  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
20146 
20150  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
20151 
20155  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
20156 
20160  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
20161 
20170  bool ShowSimpleReflection(bool & out_state, float & out_opacity, unsigned int & out_blurring, bool & out_fading, float & out_attenuation_near_distance, float & out_attenuation_far_distance) const;
20171 
20175  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
20176 
20180  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
20181 
20182 private:
20185 };
20186 
20187 
20188 
20190 class HPS_API ContourLineKit : public Object
20191 {
20192 public:
20193 
20195  ContourLineKit();
20196 
20199  ContourLineKit(ContourLineKit const & in_kit);
20200 
20204  ContourLineKit(ContourLineKit && in_that);
20205 
20209  ContourLineKit & operator=(ContourLineKit && in_that);
20210 
20212  virtual ~ContourLineKit();
20213 
20214  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
20215 
20219  static ContourLineKit GetDefault();
20220 
20223  void Set(ContourLineKit const & in_kit);
20224 
20227  void Show(ContourLineKit & out_kit) const;
20228 
20232  ContourLineKit & operator=(ContourLineKit const & in_kit);
20233 
20236  bool Empty() const;
20237 
20241  bool Equals(ContourLineKit const & in_kit) const;
20242 
20246  bool operator==(ContourLineKit const & in_kit) const;
20247 
20251  bool operator!=(ContourLineKit const & in_kit) const;
20252 
20253 
20257  ContourLineKit & SetVisibility(bool in_state);
20258 
20263  ContourLineKit & SetPositions(float in_interval, float in_offset);
20264 
20268  ContourLineKit & SetPositions(FloatArray const & in_positions);
20269 
20274  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
20275 
20279  ContourLineKit & SetColors(RGBColorArray const & in_colors);
20280 
20285  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
20286 
20290  ContourLineKit & SetColors(RGBColor const & in_color);
20291 
20295  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
20296 
20301  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20302 
20306  ContourLineKit & SetPatterns(char const * in_pattern);
20307 
20312  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20313 
20319  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20320 
20325  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20326 
20330  ContourLineKit & SetLighting(bool in_state);
20331 
20332 
20335  ContourLineKit & UnsetVisibility();
20336 
20339  ContourLineKit & UnsetPositions();
20340 
20343  ContourLineKit & UnsetColors();
20344 
20347  ContourLineKit & UnsetPatterns();
20348 
20351  ContourLineKit & UnsetWeights();
20352 
20355  ContourLineKit & UnsetLighting();
20356 
20359  ContourLineKit & UnsetEverything();
20360 
20361 
20365  bool ShowVisibility(bool & out_state) const;
20366 
20372  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20373 
20377  bool ShowColors(RGBColorArray & out_colors) const;
20378 
20382  bool ShowPatterns(UTF8Array & out_patterns) const;
20383 
20388  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20389 
20393  bool ShowLighting(bool & out_state) const;
20394 };
20395 
20399 class HPS_API ContourLineControl : public Control
20400 {
20401 public:
20402 
20404  explicit ContourLineControl(SegmentKey & in_seg);
20405 
20407  ContourLineControl(ContourLineControl const & in_that);
20408 
20413 
20417  ContourLineControl & operator=(ContourLineControl && in_that);
20418 
20420  ~ContourLineControl();
20421 
20422  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
20423 
20425  ContourLineControl & operator=(ContourLineControl const & in_that);
20426 
20427 
20431  ContourLineControl & SetVisibility(bool in_state);
20432 
20437  ContourLineControl & SetPositions(float in_interval, float in_offset);
20438 
20442  ContourLineControl & SetPositions(FloatArray const & in_positions);
20443 
20448  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20449 
20453  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20454 
20459  ContourLineControl & SetColors(size_t in_count, RGBColor const in_rgb_colors[]);
20460 
20464  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20465 
20469  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20470 
20475  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20476 
20480  ContourLineControl & SetPatterns(char const * in_pattern);
20481 
20486  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20487 
20493  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20494 
20499  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20500 
20504  ContourLineControl & SetLighting(bool in_state);
20505 
20506 
20509  ContourLineControl & UnsetVisibility();
20510 
20513  ContourLineControl & UnsetPositions();
20514 
20517  ContourLineControl & UnsetColors();
20518 
20521  ContourLineControl & UnsetPatterns();
20522 
20525  ContourLineControl & UnsetWeights();
20526 
20529  ContourLineControl & UnsetLighting();
20530 
20533  ContourLineControl & UnsetEverything();
20534 
20535 
20539  bool ShowVisibility(bool & out_state) const;
20540 
20546  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20547 
20551  bool ShowColors(RGBColorArray & out_colors) const;
20552 
20556  bool ShowPatterns(UTF8Array & out_patterns) const;
20557 
20562  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20563 
20567  bool ShowLighting(bool & out_state) const;
20568 
20569 private:
20572 };
20573 
20574 
20575 
20577 class HPS_API SubwindowKit : public Object
20578 {
20579 public:
20580 
20582  SubwindowKit();
20583 
20585  SubwindowKit(SubwindowKit const & in_kit);
20586 
20590  SubwindowKit(SubwindowKit && in_that);
20591 
20595  SubwindowKit & operator=(SubwindowKit && in_that);
20596 
20598  virtual ~SubwindowKit();
20599 
20600  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
20601 
20605  static SubwindowKit GetDefault();
20606 
20609  void Set(SubwindowKit const & in_kit);
20610 
20613  void Show(SubwindowKit & out_kit) const;
20614 
20618  SubwindowKit & operator=(SubwindowKit const & in_kit);
20619 
20622  bool Empty() const;
20623 
20627  bool Equals(SubwindowKit const & in_kit) const;
20628 
20632  bool operator==(SubwindowKit const & in_kit) const;
20633 
20637  bool operator!=(SubwindowKit const & in_kit) const;
20638 
20639 
20649  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20650 
20657  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20658 
20663  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20664 
20669  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20670 
20676  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20677 
20682  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20683 
20686  SubwindowKit & UnsetSubwindow();
20687 
20690  SubwindowKit & UnsetBackground();
20691 
20694  SubwindowKit & UnsetBorder();
20695 
20698  SubwindowKit & UnsetRenderingAlgorithm();
20699 
20702  SubwindowKit & UnsetModelCompareMode();
20703 
20706  SubwindowKit & UnsetEverything();
20707 
20712  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20713 
20718  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20719 
20723  bool ShowBorder(Subwindow::Border & out_border_type) const;
20724 
20728  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20729 
20735  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20736 };
20737 
20738 
20739 
20745 class HPS_API SubwindowControl : public Control
20746 {
20747 public:
20748 
20750  explicit SubwindowControl(SegmentKey & in_seg);
20751 
20753  SubwindowControl(SubwindowControl const & in_that);
20754 
20758  SubwindowControl(SubwindowControl && in_that);
20759 
20763  SubwindowControl & operator=(SubwindowControl && in_that);
20764 
20766  ~SubwindowControl();
20767 
20768  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
20769 
20771  SubwindowControl & operator=(SubwindowControl const & in_that);
20772 
20783  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
20784 
20791  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20792 
20797  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
20798 
20804  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20805 
20811  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
20812 
20817  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
20818 
20821  SubwindowControl & UnsetSubwindow();
20822 
20825  SubwindowControl & UnsetBackground();
20826 
20829  SubwindowControl & UnsetBorder();
20830 
20833  SubwindowControl & UnsetRenderingAlgorithm();
20834 
20837  SubwindowControl & UnsetModelCompareMode();
20838 
20841  SubwindowControl & UnsetEverything();
20842 
20843 
20848  bool ShowSubwindow(Rectangle & out_window_position, Subwindow::Type & out_subwindow_type) const;
20849 
20854  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20855 
20859  bool ShowBorder(Subwindow::Border & out_border_type) const;
20860 
20864  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20865 
20871  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
20872 
20873 private:
20875  SubwindowControl();
20876 };
20877 
20878 
20879 
20881 class HPS_API DebuggingKit : public Object
20882 {
20883 public:
20884 
20886  DebuggingKit();
20887 
20889  DebuggingKit(DebuggingKit const & in_kit);
20890 
20894  DebuggingKit(DebuggingKit && in_that);
20895 
20899  DebuggingKit & operator=(DebuggingKit && in_that);
20900 
20902  virtual ~DebuggingKit();
20903 
20904  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
20905 
20909  static DebuggingKit GetDefault();
20910 
20913  void Set(DebuggingKit const & in_kit);
20914 
20917  void Show(DebuggingKit & out_kit) const;
20918 
20922  DebuggingKit & operator=(DebuggingKit const & in_kit);
20923 
20926  bool Empty() const;
20927 
20931  bool Equals(DebuggingKit const & in_kit) const;
20932 
20936  bool operator==(DebuggingKit const & in_kit) const;
20937 
20941  bool operator!=(DebuggingKit const & in_kit) const;
20942 
20943 
20947  DebuggingKit & SetResourceMonitor(bool in_display);
20948 
20949 
20952  DebuggingKit & UnsetResourceMonitor();
20953 
20956  DebuggingKit & UnsetEverything();
20957 
20958 
20962  bool ShowResourceMonitor(bool & out_display) const;
20963 };
20964 
20965 
20968 class HPS_API DebuggingControl : public Control
20969 {
20970 public:
20971 
20973  explicit DebuggingControl(WindowKey & in_window);
20974 
20976  DebuggingControl(DebuggingControl const & in_that);
20977 
20981  DebuggingControl(DebuggingControl && in_that);
20982 
20986  DebuggingControl & operator=(DebuggingControl && in_that);
20987 
20989  ~DebuggingControl();
20990 
20991  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
20992 
20994  DebuggingControl & operator=(DebuggingControl const & in_that);
20995 
21000  DebuggingControl & SetResourceMonitor(bool in_display);
21001 
21005  bool ShowResourceMonitor(bool & out_display) const;
21006 
21010  bool ShowLastUpdateInfo(UpdateInfo & out_info);
21011 
21012 private:
21014  DebuggingControl();
21015 };
21016 
21017 
21019 class HPS_API WindowInfoKit : public Object
21020 {
21021 public:
21022 
21024  WindowInfoKit();
21025 
21027  WindowInfoKit(WindowInfoKit const & in_kit);
21028 
21032  WindowInfoKit(WindowInfoKit && in_that);
21033 
21037  WindowInfoKit & operator=(WindowInfoKit && in_that);
21038 
21040  virtual ~WindowInfoKit();
21041 
21042  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
21043 
21046  void Set(WindowInfoKit const & in_kit);
21047 
21050  void Show(WindowInfoKit & out_kit) const;
21051 
21055  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
21056 
21059  bool Empty() const;
21060 
21064  bool Equals(WindowInfoKit const & in_kit) const;
21065 
21069  bool operator==(WindowInfoKit const & in_kit) const;
21070 
21074  bool operator!=(WindowInfoKit const & in_kit) const;
21075 
21076 
21081  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
21082 
21087  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
21088 
21093  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
21094 
21099  WindowInfoKit & SetWindowSize(float in_width, float in_height);
21100 
21101 
21104  WindowInfoKit & UnsetPhysicalPixels();
21105 
21108  WindowInfoKit & UnsetPhysicalSize();
21109 
21112  WindowInfoKit & UnsetWindowPixels();
21113 
21116  WindowInfoKit & UnsetWindowSize();
21117 
21120  WindowInfoKit & UnsetEverything();
21121 
21122 
21127  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21128 
21133  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21134 
21139  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21140 
21145  bool ShowWindowSize(float & out_width, float & out_height) const;
21146 
21152  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21153 
21157  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21158 
21162  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21163 };
21164 
21165 
21168 class HPS_API WindowInfoControl : public Control
21169 {
21170 public:
21171 
21173  explicit WindowInfoControl(WindowKey & in_window);
21174 
21176  WindowInfoControl(WindowInfoControl const & in_that);
21177 
21182 
21186  WindowInfoControl & operator=(WindowInfoControl && in_that);
21187 
21189  ~WindowInfoControl();
21190 
21191  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
21192 
21194  WindowInfoControl & operator=(WindowInfoControl const & in_that);
21195 
21200  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
21201 
21206  bool ShowPhysicalSize(float & out_width, float & out_height) const;
21207 
21212  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
21213 
21218  bool ShowWindowSize(float & out_width, float & out_height) const;
21219 
21225  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
21226 
21230  bool ShowWindowAspectRatio(float & out_window_aspect) const;
21231 
21235  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
21236 
21241  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
21242 
21247  bool ShowLastUpdateTime(Time & out_time) const;
21248 
21252  bool ShowDepthPeelingLayers(size_t & out_layers) const;
21253 
21257  bool ShowVideoMemory(size_t & out_video_memory) const;
21258 
21262  bool ShowDepthBufferSize(size_t & out_bits) const;
21263 
21267  bool ShowMaxLights(size_t & out_lights) const;
21268 
21272  bool ShowColorBitPlanes(size_t & out_planes) const;
21273 
21274 private:
21277 };
21278 
21280 class HPS_API FontInfoState : public Object
21281 {
21282 public:
21283 
21285  FontInfoState();
21286 
21288  FontInfoState(FontInfoState const & in_kit);
21289 
21293  FontInfoState(FontInfoState && in_that);
21294 
21298  FontInfoState & operator=(FontInfoState && in_that);
21299 
21301  virtual ~FontInfoState();
21302 
21303  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
21304 
21307  void Assign(FontInfoState const & in_that);
21308 
21311  void Set(FontInfoState const & in_kit);
21312 
21315  void Show(FontInfoState & out_kit) const;
21316 
21320  FontInfoState & operator=(FontInfoState const & in_kit);
21321 
21324  bool Empty() const;
21325 
21329  bool Equals(FontInfoState const & in_kit) const;
21330 
21334  bool operator==(FontInfoState const & in_kit) const;
21335 
21339  bool operator!=(FontInfoState const & in_kit) const;
21340 
21343  UTF8 GetName() const;
21344 
21347  bool GetShellConvertibility() const;
21348 };
21349 
21350 
21355 class HPS_API AttributeLockKit : public Object
21356 {
21357 public:
21358 
21360  AttributeLockKit();
21361 
21363  AttributeLockKit(AttributeLockKit const & in_kit);
21364 
21368  AttributeLockKit(AttributeLockKit && in_that);
21369 
21373  AttributeLockKit & operator=(AttributeLockKit && in_that);
21374 
21376  virtual ~AttributeLockKit();
21377 
21378  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
21379 
21383  static AttributeLockKit GetDefault();
21384 
21387  void Set(AttributeLockKit const & in_kit);
21388 
21391  void Show(AttributeLockKit & out_kit) const;
21392 
21396  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
21397 
21400  bool Empty() const;
21401 
21405  bool Equals(AttributeLockKit const & in_kit) const;
21406 
21410  bool operator==(AttributeLockKit const & in_kit) const;
21411 
21415  bool operator!=(AttributeLockKit const & in_kit) const;
21416 
21422  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
21423 
21428  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21429 
21435  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21436 
21442  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21443 
21444 
21447  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21448 
21451  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
21452 
21455  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21456 
21459  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21460 
21463  AttributeLockKit & UnsetEverything();
21464 
21465 
21470  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21471 
21476  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21477 
21482  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21483 
21488  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21489 };
21490 
21491 
21496 class HPS_API AttributeLockControl : public Control
21497 {
21498 public:
21499 
21501  explicit AttributeLockControl(SegmentKey & in_seg);
21502 
21507 
21511  AttributeLockControl & operator=(AttributeLockControl && in_that);
21512 
21514  AttributeLockControl(AttributeLockControl const & in_that);
21515 
21518 
21519  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
21520 
21522  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21523 
21524 
21530  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21531 
21536  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21537 
21543  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21544 
21550  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21551 
21552 
21555  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21556 
21559  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21560 
21563  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21564 
21567  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21568 
21571  AttributeLockControl & UnsetEverything();
21572 
21573 
21578  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21579 
21584  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21585 
21590  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21591 
21596  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21597 
21598 private:
21601 };
21602 
21606 
21607 class HPS_API GeometryKey : public Key
21608 {
21609 public:
21611  GeometryKey();
21612 
21616  explicit GeometryKey(Key const & in_that);
21617 
21620  GeometryKey(GeometryKey const & in_that);
21621 
21625  GeometryKey & operator=(GeometryKey const & in_that);
21626 
21630  GeometryKey(GeometryKey && in_that);
21631 
21635  GeometryKey & operator=(GeometryKey && in_that);
21636 
21637  ~GeometryKey();
21638 
21639  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
21640 
21641 
21645  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21646 
21650  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21651 
21652 
21653 
21660  GeometryKey & SetPriority(int in_priority);
21661 
21664  GeometryKey & UnsetPriority();
21665 
21669  bool ShowPriority(int & out_priority) const;
21670 
21671 
21677  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21678 
21683  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21684 
21689  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21690 
21694  GeometryKey & UnsetUserData(intptr_t in_index);
21695 
21700  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21701 
21705  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21706 
21709  GeometryKey & UnsetAllUserData();
21710 
21712  size_t ShowUserDataCount() const;
21713 
21717  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21718 
21723  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21724 
21729  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21730 
21734  bool ShowBoundings(BoundingKit & out_kit) const;
21735 };
21736 
21737 
21739 class HPS_API LineKit : public Object
21740 {
21741 public:
21743  LineKit();
21744 
21747  LineKit(LineKit const & in_kit);
21748 
21752  LineKit(LineKit && in_that);
21753 
21757  LineKit & operator=(LineKit && in_that);
21758 
21759  virtual ~LineKit();
21760 
21761  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
21762 
21765  void Consume(LineKit & in_kit);
21766 
21769  void Set(LineKit const & in_kit);
21770 
21773  void Show(LineKit & out_kit) const;
21774 
21778  LineKit & operator=(LineKit const & in_kit);
21779 
21782  bool Empty() const;
21783 
21787  bool Equals(LineKit const & in_kit) const;
21788 
21792  bool operator==(LineKit const & in_kit) const;
21793 
21797  bool operator!=(LineKit const & in_kit) const;
21798 
21801  size_t GetPointCount() const;
21802 
21809  LineKit & SetPriority(int in_priority);
21810 
21813  LineKit & UnsetPriority();
21814 
21818  bool ShowPriority(int & out_priority) const;
21819 
21820 
21824  LineKit & SetPoints(PointArray const & in_points);
21825 
21830  LineKit & SetPoints(size_t in_count, Point const in_points []);
21831 
21832 
21835  LineKit & UnsetPoints();
21836 
21839  LineKit & UnsetEverything();
21840 
21841 
21845  bool ShowPoints(PointArray & out_points) const;
21846 
21852  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
21853 
21858  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
21859 
21865  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
21866 
21867 
21873  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21874 
21879  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21880 
21885  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
21886 
21892  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21893 
21899  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21900 
21906  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21907 
21912  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21913 
21918  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21919 
21923  LineKit & UnsetUserData(intptr_t in_index);
21924 
21929  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21930 
21934  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
21935 
21938  LineKit & UnsetAllUserData();
21939 
21941  size_t ShowUserDataCount() const;
21942 
21946  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21947 
21952  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21953 
21958  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21959 };
21960 
21962 class HPS_API LineKey : public GeometryKey
21963 {
21964 public:
21966  LineKey();
21967 
21971  explicit LineKey(Key const & in_that);
21972 
21975  LineKey(LineKey const & in_that);
21976 
21980  LineKey & operator=(LineKey const & in_that);
21981 
21985  LineKey(LineKey && in_that);
21986 
21990  LineKey & operator=(LineKey && in_that);
21991 
21992  ~LineKey();
21993 
21994  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
21995 
21996 
21999  void Consume(LineKit & in_kit);
22000 
22003  void Set(LineKit const & in_kit);
22004 
22007  void Show(LineKit & out_kit) const;
22008 
22011  size_t GetPointCount() const;
22012 
22016  LineKey & SetPoints(PointArray const & in_points);
22017 
22022  LineKey & SetPoints(size_t in_count, Point const in_points []);
22023 
22024 
22028  bool ShowPoints(PointArray & out_points) const;
22029 
22035  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22036 
22041  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22042 
22048  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22049 
22050 
22056  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22057 
22062  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22063 
22068  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22069 
22075  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22076 
22082  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22083 };
22084 
22085 
22086 
22088 class HPS_API MarkerKit : public Object
22089 {
22090 public:
22092  MarkerKit();
22093 
22096  MarkerKit(MarkerKit const & in_kit);
22097 
22101  MarkerKit(MarkerKit && in_that);
22102 
22106  MarkerKit & operator=(MarkerKit && in_that);
22107 
22108  virtual ~MarkerKit();
22109 
22110  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
22111 
22114  void Consume(MarkerKit & in_kit);
22115 
22118  void Set(MarkerKit const & in_kit);
22119 
22122  void Show(MarkerKit & out_kit) const;
22123 
22127  MarkerKit & operator=(MarkerKit const & in_kit);
22128 
22131  bool Empty() const;
22132 
22136  bool Equals(MarkerKit const & in_kit) const;
22137 
22141  bool operator==(MarkerKit const & in_kit) const;
22142 
22146  bool operator!=(MarkerKit const & in_kit) const;
22147 
22148 
22155  MarkerKit & SetPriority(int in_priority);
22156 
22159  MarkerKit & UnsetPriority();
22160 
22164  bool ShowPriority(int & out_priority) const;
22165 
22169  MarkerKit & SetPoint(Point const & in_point);
22170 
22171 
22174  MarkerKit & UnsetPoint();
22175 
22178  MarkerKit & UnsetEverything();
22179 
22180 
22184  bool ShowPoint(HPS::Point & out_point) const;
22185 
22191  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22192 
22197  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22198 
22203  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22204 
22208  MarkerKit & UnsetUserData(intptr_t in_index);
22209 
22214  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22215 
22219  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
22220 
22223  MarkerKit & UnsetAllUserData();
22224 
22226  size_t ShowUserDataCount() const;
22227 
22231  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22232 
22237  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22238 
22243  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22244 };
22245 
22247 class HPS_API MarkerKey : public GeometryKey
22248 {
22249 public:
22251  MarkerKey();
22252 
22256  explicit MarkerKey(Key const & in_that);
22257 
22260  MarkerKey(MarkerKey const & in_that);
22261 
22265  MarkerKey & operator=(MarkerKey const & in_that);
22266 
22270  MarkerKey(MarkerKey && in_that);
22271 
22275  MarkerKey & operator=(MarkerKey && in_that);
22276 
22277  ~MarkerKey();
22278 
22279  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
22280 
22281 
22284  void Consume(MarkerKit & in_kit);
22285 
22288  void Set(MarkerKit const & in_kit);
22289 
22292  void Show(MarkerKit & out_kit) const;
22293 
22294 
22298  MarkerKey & SetPoint(Point const & in_point);
22299 
22303  bool ShowPoint(Point & out_point) const;
22304 };
22305 
22306 
22307 
22309 class HPS_API DistantLightKit : public Object
22310 {
22311 public:
22313  DistantLightKit();
22314 
22317  DistantLightKit(DistantLightKit const & in_kit);
22318 
22322  DistantLightKit(DistantLightKit && in_that);
22323 
22327  DistantLightKit & operator=(DistantLightKit && in_that);
22328 
22329  virtual ~DistantLightKit();
22330 
22331  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
22332 
22335  void Consume(DistantLightKit & in_kit);
22336 
22339  void Set(DistantLightKit const & in_kit);
22340 
22343  void Show(DistantLightKit & out_kit) const;
22344 
22348  DistantLightKit & operator=(DistantLightKit const & in_kit);
22349 
22352  bool Empty() const;
22353 
22357  bool Equals(DistantLightKit const & in_kit) const;
22358 
22362  bool operator==(DistantLightKit const & in_kit) const;
22363 
22367  bool operator!=(DistantLightKit const & in_kit) const;
22368 
22369 
22376  DistantLightKit & SetPriority(int in_priority);
22377 
22383  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
22384 
22388  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
22389 
22393  DistantLightKit & SetColorByIndex(float in_index);
22394 
22400  DistantLightKit & SetCameraRelative(bool in_state);
22401 
22402 
22405  DistantLightKit & UnsetPriority();
22406 
22409  DistantLightKit & UnsetDirection();
22410 
22413  DistantLightKit & UnsetColor();
22414 
22417  DistantLightKit & UnsetCameraRelative();
22418 
22421  DistantLightKit & UnsetEverything();
22422 
22423 
22427  bool ShowPriority(int & out_priority) const;
22428 
22432  bool ShowDirection(HPS::Vector & out_vector) const;
22433 
22439  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22440 
22444  bool ShowCameraRelative(bool & out_state) const;
22445 
22451  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22452 
22457  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22458 
22463  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22464 
22468  DistantLightKit & UnsetUserData(intptr_t in_index);
22469 
22474  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22475 
22479  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
22480 
22483  DistantLightKit & UnsetAllUserData();
22484 
22486  size_t ShowUserDataCount() const;
22487 
22491  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22492 
22497  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22498 
22503  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22504 };
22505 
22506 
22507 
22509 class HPS_API DistantLightKey : public GeometryKey
22510 {
22511 public:
22513  DistantLightKey();
22514 
22518  explicit DistantLightKey(Key const & in_that);
22519 
22522  DistantLightKey(DistantLightKey const & in_that);
22523 
22527  DistantLightKey & operator=(DistantLightKey const & in_that);
22528 
22532  DistantLightKey(DistantLightKey && in_that);
22533 
22537  DistantLightKey & operator=(DistantLightKey && in_that);
22538 
22539  ~DistantLightKey();
22540 
22541  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
22542 
22545  void Consume(DistantLightKit & in_kit);
22546 
22549  void Set(DistantLightKit const & in_kit);
22550 
22553  void Show(DistantLightKit & out_kit) const;
22554 
22555 
22560  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
22561 
22565  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22566 
22570  DistantLightKey & SetColorByIndex(float in_index);
22571 
22576  DistantLightKey & SetCameraRelative(bool in_state);
22577 
22578 
22581  DistantLightKey & UnsetColor();
22582 
22583 
22587  bool ShowDirection(HPS::Vector & out_vector) const;
22588 
22594  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22595 
22599  bool ShowCameraRelative(bool & out_state) const;
22600 };
22601 
22602 
22603 
22604 
22606 class HPS_API CylinderKit : public Object
22607 {
22608 public:
22610  CylinderKit();
22611 
22614  CylinderKit(CylinderKit const & in_kit);
22615 
22619  CylinderKit(CylinderKit && in_that);
22620 
22624  CylinderKit & operator=(CylinderKit && in_that);
22625 
22626  virtual ~CylinderKit();
22627 
22628  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
22629 
22632  void Consume(CylinderKit & in_kit);
22633 
22636  void Set(CylinderKit const & in_kit);
22637 
22640  void Show(CylinderKit & out_kit) const;
22641 
22645  CylinderKit & operator=(CylinderKit const & in_kit);
22646 
22649  bool Empty() const;
22650 
22654  bool Equals(CylinderKit const & in_kit) const;
22655 
22659  bool operator==(CylinderKit const & in_kit) const;
22660 
22664  bool operator!=(CylinderKit const & in_kit) const;
22665 
22668  size_t GetPointCount() const;
22669 
22676  CylinderKit & SetPriority(int in_priority);
22677 
22680  CylinderKit & UnsetPriority();
22681 
22685  bool ShowPriority(int & out_priority) const;
22686 
22687 
22691  CylinderKit & SetPoints(PointArray const & in_points);
22692 
22697  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22698 
22702  CylinderKit & SetRadii(FloatArray const & in_radii);
22703 
22708  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22709 
22713  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22714 
22715 
22718  CylinderKit & UnsetPoints();
22719 
22722  CylinderKit & UnsetRadii();
22723 
22726  CylinderKit & UnsetCaps();
22727 
22730  CylinderKit & UnsetEverything();
22731 
22732 
22736  bool ShowPoints(PointArray & out_points) const;
22737 
22743  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
22744 
22749  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
22750 
22756  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
22757 
22761  bool ShowRadii(FloatArray & out_radii) const;
22762 
22766  bool ShowCaps(Cylinder::Capping & out_caps) const;
22767 
22768 
22775  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22776 
22782  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22783 
22790  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22791 
22798  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22799 
22806  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22807 
22814  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22815 
22821  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22822 
22823 
22830  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22831 
22837  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22838 
22845  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22846 
22853  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22854 
22861  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22862 
22869  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22870 
22876  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22877 
22878 
22881  CylinderKit & UnsetVertexColors();
22882 
22887  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22888 
22892  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
22893 
22894 
22898  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
22899 
22905  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22906 
22911  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
22912 
22913 
22925  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22926 
22939  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22940 
22946  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22947 
22952  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22953 
22958  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22959 
22963  CylinderKit & UnsetUserData(intptr_t in_index);
22964 
22969  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22970 
22974  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
22975 
22978  CylinderKit & UnsetAllUserData();
22979 
22981  size_t ShowUserDataCount() const;
22982 
22986  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22987 
22992  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22993 
22998  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22999 };
23000 
23001 
23002 
23004 class HPS_API CylinderKey : public GeometryKey
23005 {
23006 public:
23008  CylinderKey();
23009 
23013  explicit CylinderKey(Key const & in_that);
23014 
23017  CylinderKey(CylinderKey const & in_that);
23018 
23022  CylinderKey & operator=(CylinderKey const & in_that);
23023 
23027  CylinderKey(CylinderKey && in_that);
23028 
23032  CylinderKey & operator=(CylinderKey && in_that);
23033 
23034  ~CylinderKey();
23035 
23036  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
23037 
23040  void Consume(CylinderKit & in_kit);
23041 
23044  void Set(CylinderKit const & in_kit);
23045 
23046 
23052  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23053 
23058  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23059 
23064  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23065 
23071  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23072 
23078  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23079 
23080 
23086  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
23087 
23092  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
23093 
23098  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
23099 
23105  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
23106 
23112  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
23113 
23114 
23117  void Show(CylinderKit & out_kit) const;
23118 
23121  size_t GetPointCount() const;
23122 
23126  bool ShowPoints(PointArray & out_points) const;
23127 
23133  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23134 
23139  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23140 
23146  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23147 
23151  bool ShowRadii(FloatArray & out_radii) const;
23152 
23156  bool ShowCaps(Cylinder::Capping & out_caps) const;
23157 
23158 
23165  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23166 
23173  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23174 
23181  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23182 
23183 
23190  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23191 
23198  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23199 
23206  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
23207 
23208 
23211  CylinderKey & UnsetVertexColors();
23212 
23217  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
23218 
23222  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
23223 
23229  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
23230 
23231 
23243  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23244 
23257  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
23258 };
23259 
23260 
23261 
23262 
23264 class HPS_API SphereKit : public Object
23265 {
23266 public:
23268  SphereKit();
23269 
23272  SphereKit(SphereKit const & in_kit);
23273 
23277  SphereKit(SphereKit && in_that);
23278 
23282  SphereKit & operator=(SphereKit && in_that);
23283 
23284  virtual ~SphereKit();
23285 
23286  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
23287 
23290  void Consume(SphereKit & in_kit);
23291 
23294  void Set(SphereKit const & in_kit);
23295 
23298  void Show(SphereKit & out_kit) const;
23299 
23303  SphereKit & operator=(SphereKit const & in_kit);
23304 
23307  bool Empty() const;
23308 
23312  bool Equals(SphereKit const & in_kit) const;
23313 
23317  bool operator==(SphereKit const & in_kit) const;
23318 
23322  bool operator!=(SphereKit const & in_kit) const;
23323 
23330  SphereKit & SetPriority(int in_priority);
23331 
23334  SphereKit & UnsetPriority();
23335 
23339  bool ShowPriority(int & out_priority) const;
23340 
23344  SphereKit & SetCenter(Point const & in_center);
23345 
23349  SphereKit & SetRadius(float in_radius);
23350 
23355  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23356 
23357 
23360  SphereKit & UnsetCenter();
23361 
23364  SphereKit & UnsetRadius();
23365 
23368  SphereKit & UnsetBasis();
23369 
23372  SphereKit & UnsetEverything();
23373 
23374 
23378  bool ShowCenter(Point & out_center) const;
23379 
23383  bool ShowRadius(float & out_radius) const;
23384 
23389  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23390 
23396  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23397 
23402  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23403 
23408  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23409 
23413  SphereKit & UnsetUserData(intptr_t in_index);
23414 
23419  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23420 
23424  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
23425 
23428  SphereKit & UnsetAllUserData();
23429 
23431  size_t ShowUserDataCount() const;
23432 
23436  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23437 
23442  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23443 
23448  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23449 };
23450 
23452 class HPS_API SphereKey : public GeometryKey
23453 {
23454 public:
23456  SphereKey();
23457 
23461  explicit SphereKey(Key const & in_that);
23462 
23465  SphereKey(SphereKey const & in_that);
23466 
23470  SphereKey & operator=(SphereKey const & in_that);
23471 
23475  SphereKey(SphereKey && in_that);
23476 
23480  SphereKey & operator=(SphereKey && in_that);
23481 
23482  ~SphereKey();
23483 
23484  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
23485 
23488  void Consume(SphereKit & in_kit);
23489 
23492  void Set(SphereKit const & in_kit);
23493 
23496  void Show(SphereKit & out_kit) const;
23497 
23498 
23502  SphereKey & SetCenter(Point const & in_center);
23503 
23507  SphereKey & SetRadius(float in_radius);
23508 
23513  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
23514 
23515 
23519  bool ShowCenter(Point & out_center) const;
23520 
23524  bool ShowRadius(float & out_radius) const;
23525 
23530  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
23531 };
23532 
23533 
23534 
23535 
23537 class HPS_API CircleKit : public Object
23538 {
23539 public:
23541  CircleKit();
23542 
23545  CircleKit(CircleKit const & in_kit);
23546 
23550  CircleKit(CircleKit && in_that);
23551 
23555  CircleKit & operator=(CircleKit && in_that);
23556 
23557  virtual ~CircleKit();
23558 
23559  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
23560 
23563  void Consume(CircleKit & in_kit);
23564 
23567  void Set(CircleKit const & in_kit);
23568 
23571  void Show(CircleKit & out_kit) const;
23572 
23576  CircleKit & operator=(CircleKit const & in_kit);
23577 
23580  bool Empty() const;
23581 
23585  bool Equals(CircleKit const & in_kit) const;
23586 
23590  bool operator==(CircleKit const & in_kit) const;
23591 
23595  bool operator!=(CircleKit const & in_kit) const;
23596 
23603  CircleKit & SetPriority(int const in_priority);
23604 
23607  CircleKit & UnsetPriority();
23608 
23612  bool ShowPriority(int & out_priority) const;
23613 
23614 
23615 
23619  CircleKit & SetCenter(Point const & in_center);
23620 
23624  CircleKit & SetRadius(float in_radius);
23625 
23629  CircleKit & SetNormal(Vector const & in_normal);
23630 
23631 
23634  CircleKit & UnsetCenter();
23635 
23638  CircleKit & UnsetRadius();
23639 
23642  CircleKit & UnsetNormal();
23643 
23646  CircleKit & UnsetEverything();
23647 
23648 
23652  bool ShowCenter(Point & out_center) const;
23653 
23657  bool ShowRadius(float & out_radius) const;
23658 
23662  bool ShowNormal(Vector & out_normal) const;
23663 
23669  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23670 
23675  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23676 
23681  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23682 
23686  CircleKit & UnsetUserData(intptr_t in_index);
23687 
23692  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23693 
23697  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23698 
23701  CircleKit & UnsetAllUserData();
23702 
23704  size_t ShowUserDataCount() const;
23705 
23709  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23710 
23715  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23716 
23721  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23722 };
23723 
23724 
23727 class HPS_API CircleKey : public GeometryKey
23728 {
23729 public:
23731  CircleKey();
23732 
23736  explicit CircleKey(Key const & in_that);
23737 
23740  CircleKey(CircleKey const & in_that);
23741 
23745  CircleKey & operator=(CircleKey const & in_that);
23746 
23750  CircleKey(CircleKey && in_that);
23751 
23755  CircleKey & operator=(CircleKey && in_that);
23756 
23757  ~CircleKey();
23758 
23759  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
23760 
23761 
23764  void Consume(CircleKit & in_kit);
23765 
23768  void Set(CircleKit const & in_kit);
23769 
23772  void Show(CircleKit & out_kit) const;
23773 
23774 
23778  CircleKey & SetCenter(Point const & in_center);
23779 
23783  CircleKey & SetRadius(float in_radius);
23784 
23788  CircleKey & SetNormal(Vector const & in_normal);
23789 
23790 
23794  bool ShowCenter(Point & out_center) const;
23795 
23799  bool ShowRadius(float & out_radius) const;
23800 
23804  bool ShowNormal(Vector & out_normal) const;
23805 };
23806 
23807 
23808 
23809 
23811 class HPS_API CircularArcKit : public Object
23812 {
23813 public:
23815  CircularArcKit();
23816 
23819  CircularArcKit(CircularArcKit const & in_kit);
23820 
23824  CircularArcKit(CircularArcKit && in_that);
23825 
23829  CircularArcKit & operator=(CircularArcKit && in_that);
23830 
23831  virtual ~CircularArcKit();
23832 
23833  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
23834 
23837  void Consume(CircularArcKit & in_kit);
23838 
23841  void Set(CircularArcKit const & in_kit);
23842 
23845  void Show(CircularArcKit & out_kit) const;
23846 
23850  CircularArcKit & operator=(CircularArcKit const & in_kit);
23851 
23854  bool Empty() const;
23855 
23859  bool Equals(CircularArcKit const & in_kit) const;
23860 
23864  bool operator==(CircularArcKit const & in_kit) const;
23865 
23869  bool operator!=(CircularArcKit const & in_kit) const;
23870 
23877  CircularArcKit & SetPriority(int in_priority);
23878 
23881  CircularArcKit & UnsetPriority();
23882 
23886  bool ShowPriority(int & out_priority) const;
23887 
23888 
23892  CircularArcKit & SetStart(Point const & in_start);
23893 
23897  CircularArcKit & SetMiddle(Point const & in_middle);
23898 
23902  CircularArcKit & SetEnd(Point const & in_end);
23903 
23904 
23907  CircularArcKit & UnsetStart();
23908 
23911  CircularArcKit & UnsetMiddle();
23912 
23915  CircularArcKit & UnsetEnd();
23916 
23919  CircularArcKit & UnsetEverything();
23920 
23921 
23925  bool ShowStart(Point & out_start) const;
23926 
23930  bool ShowMiddle(Point & out_middle) const;
23931 
23935  bool ShowEnd(Point & out_end) const;
23936 
23942  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23943 
23948  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23949 
23954  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23955 
23959  CircularArcKit & UnsetUserData(intptr_t in_index);
23960 
23965  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23966 
23970  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
23971 
23974  CircularArcKit & UnsetAllUserData();
23975 
23977  size_t ShowUserDataCount() const;
23978 
23982  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23983 
23988  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23989 
23994  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23995 };
23996 
23999 class HPS_API CircularArcKey : public GeometryKey
24000 {
24001 public:
24003  CircularArcKey();
24004 
24008  explicit CircularArcKey(Key const & in_that);
24009 
24012  CircularArcKey(CircularArcKey const & in_that);
24013 
24017  CircularArcKey & operator=(CircularArcKey const & in_that);
24018 
24022  CircularArcKey(CircularArcKey && in_that);
24023 
24027  CircularArcKey & operator=(CircularArcKey && in_that);
24028 
24029  ~CircularArcKey();
24030 
24031  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
24032 
24033 
24036  void Consume(CircularArcKit & in_kit);
24037 
24040  void Set(CircularArcKit const & in_kit);
24041 
24044  void Show(CircularArcKit & out_kit) const;
24045 
24046 
24050  CircularArcKey & SetStart(Point const & in_start);
24051 
24055  CircularArcKey & SetMiddle(Point const & in_middle);
24056 
24060  CircularArcKey & SetEnd(Point const & in_end);
24061 
24062 
24066  bool ShowStart(Point & out_start) const;
24067 
24071  bool ShowMiddle(Point & out_middle) const;
24072 
24076  bool ShowEnd(Point & out_end) const;
24077 };
24078 
24079 
24080 
24082 class HPS_API CircularWedgeKit : public Object
24083 {
24084 public:
24086  CircularWedgeKit();
24087 
24090  CircularWedgeKit(CircularWedgeKit const & in_kit);
24091 
24095  CircularWedgeKit(CircularWedgeKit && in_that);
24096 
24100  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
24101 
24102  virtual ~CircularWedgeKit();
24103 
24104  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
24105 
24108  void Consume(CircularWedgeKit & in_kit);
24109 
24112  void Set(CircularWedgeKit const & in_kit);
24113 
24116  void Show(CircularWedgeKit & out_kit) const;
24117 
24121  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
24122 
24125  bool Empty() const;
24126 
24130  bool Equals(CircularWedgeKit const & in_kit) const;
24131 
24135  bool operator==(CircularWedgeKit const & in_kit) const;
24136 
24140  bool operator!=(CircularWedgeKit const & in_kit) const;
24141 
24142 
24149  CircularWedgeKit & SetPriority(int in_priority);
24150 
24153  CircularWedgeKit & UnsetPriority();
24154 
24158  bool ShowPriority(int & out_priority) const;
24159 
24160 
24164  CircularWedgeKit & SetStart(Point const & in_start);
24165 
24169  CircularWedgeKit & SetMiddle(Point const & in_middle);
24170 
24174  CircularWedgeKit & SetEnd(Point const & in_end);
24175 
24176 
24179  CircularWedgeKit & UnsetStart();
24180 
24183  CircularWedgeKit & UnsetMiddle();
24184 
24187  CircularWedgeKit & UnsetEnd();
24188 
24191  CircularWedgeKit & UnsetEverything();
24192 
24193 
24197  bool ShowStart(Point & out_start) const;
24198 
24202  bool ShowMiddle(Point & out_middle) const;
24203 
24207  bool ShowEnd(Point & out_end) const;
24208 
24214  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24215 
24220  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24221 
24226  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24227 
24231  CircularWedgeKit & UnsetUserData(intptr_t in_index);
24232 
24237  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24238 
24242  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
24243 
24246  CircularWedgeKit & UnsetAllUserData();
24247 
24249  size_t ShowUserDataCount() const;
24250 
24254  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24255 
24260  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24261 
24266  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24267 };
24268 
24269 
24273 class HPS_API CircularWedgeKey : public GeometryKey
24274 {
24275 public:
24277  CircularWedgeKey();
24278 
24282  explicit CircularWedgeKey(Key const & in_that);
24283 
24286  CircularWedgeKey(CircularWedgeKey const & in_that);
24287 
24291  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
24292 
24296  CircularWedgeKey(CircularWedgeKey && in_that);
24297 
24301  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
24302 
24303  ~CircularWedgeKey();
24304 
24305  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
24306 
24307 
24310  void Consume(CircularWedgeKit & in_kit);
24311 
24314  void Set(CircularWedgeKit const & in_kit);
24315 
24318  void Show(CircularWedgeKit & out_kit) const;
24319 
24320 
24324  CircularWedgeKey & SetStart(Point const & in_start);
24325 
24329  CircularWedgeKey & SetMiddle(Point const & in_middle);
24330 
24334  CircularWedgeKey & SetEnd(Point const & in_end);
24335 
24336 
24340  bool ShowStart(Point & out_start) const;
24341 
24345  bool ShowMiddle(Point & out_middle) const;
24346 
24350  bool ShowEnd(Point & out_end) const;
24351 };
24352 
24353 
24354 
24356 class HPS_API CuttingSectionKit : public Object
24357 {
24358 public:
24361 
24364  CuttingSectionKit(CuttingSectionKit const & in_kit);
24365 
24370 
24374  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
24375 
24376  virtual ~CuttingSectionKit();
24377 
24378  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
24379 
24382  void Consume(CuttingSectionKit & in_kit);
24383 
24386  void Set(CuttingSectionKit const & in_kit);
24387 
24390  void Show(CuttingSectionKit & out_kit) const;
24391 
24395  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
24396 
24399  bool Empty() const;
24400 
24404  bool Equals(CuttingSectionKit const & in_kit) const;
24405 
24409  bool operator==(CuttingSectionKit const & in_kit) const;
24410 
24414  bool operator!=(CuttingSectionKit const & in_kit) const;
24415 
24422  CuttingSectionKit & SetPriority(int in_priority);
24423 
24426  CuttingSectionKit & UnsetPriority();
24427 
24431  bool ShowPriority(int & out_priority) const;
24432 
24433 
24437  CuttingSectionKit & SetPlanes(Plane const & in_plane);
24438 
24442  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
24443 
24448  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
24449 
24455  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24456 
24457 
24460  CuttingSectionKit & UnsetPlanes();
24461 
24464  CuttingSectionKit & UnsetVisualization();
24465 
24468  CuttingSectionKit & UnsetEverything();
24469 
24470 
24473  size_t GetPlaneCount() const;
24474 
24478  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24479 
24485  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24486 
24487 
24494  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24495 
24501  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24502 
24509  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24510 
24517  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24518 
24526  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24527 
24533  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24534 
24539  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24540 
24545  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24546 
24550  CuttingSectionKit & UnsetUserData(intptr_t in_index);
24551 
24556  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24557 
24561  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
24562 
24565  CuttingSectionKit & UnsetAllUserData();
24566 
24568  size_t ShowUserDataCount() const;
24569 
24573  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24574 
24579  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24580 
24585  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24586 };
24587 
24588 
24590 class HPS_API CuttingSectionKey : public GeometryKey
24591 {
24592 public:
24595 
24599  explicit CuttingSectionKey(Key const & in_that);
24600 
24603  CuttingSectionKey(CuttingSectionKey const & in_that);
24604 
24608  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24609 
24614 
24618  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24619 
24620  ~CuttingSectionKey();
24621 
24622  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
24623 
24624 
24627  void Consume(CuttingSectionKit & in_kit);
24628 
24631  void Set(CuttingSectionKit const & in_kit);
24632 
24635  void Show(CuttingSectionKit & out_kit) const;
24636 
24637 
24641  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24642 
24646  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24647 
24652  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24653 
24659  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24660 
24661 
24664  size_t GetPlaneCount() const;
24665 
24669  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
24670 
24676  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24677 
24678 
24685  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24686 
24692  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24693 
24700  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24701 
24708  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24709 
24717  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24718 };
24719 
24720 
24721 
24723 class HPS_API InfiniteLineKit : public Object
24724 {
24725 public:
24727  InfiniteLineKit();
24728 
24731  InfiniteLineKit(InfiniteLineKit const & in_kit);
24732 
24736  InfiniteLineKit(InfiniteLineKit && in_that);
24737 
24741  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24742 
24743  virtual ~InfiniteLineKit();
24744 
24745  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
24746 
24749  void Consume(InfiniteLineKit & in_kit);
24750 
24753  void Set(InfiniteLineKit const & in_kit);
24754 
24757  void Show(InfiniteLineKit & out_kit) const;
24758 
24762  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24763 
24766  bool Empty() const;
24767 
24771  bool Equals(InfiniteLineKit const & in_kit) const;
24772 
24776  bool operator==(InfiniteLineKit const & in_kit) const;
24777 
24781  bool operator!=(InfiniteLineKit const & in_kit) const;
24782 
24789  InfiniteLineKit & SetPriority(int in_priority);
24790 
24793  InfiniteLineKit & UnsetPriority();
24794 
24798  bool ShowPriority(int & out_priority) const;
24799 
24800 
24804  InfiniteLineKit & SetFirst(Point const & in_first);
24805 
24809  InfiniteLineKit & SetSecond(Point const & in_second);
24810 
24814  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
24815 
24816 
24819  InfiniteLineKit & UnsetFirst();
24820 
24823  InfiniteLineKit & UnsetSecond();
24824 
24827  InfiniteLineKit & UnsetType();
24828 
24831  InfiniteLineKit & UnsetEverything();
24832 
24833 
24837  bool ShowFirst(Point & out_first) const;
24838 
24842  bool ShowSecond(Point & out_second) const;
24843 
24847  bool ShowType(InfiniteLine::Type & out_type) const;
24848 
24854  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24855 
24860  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24861 
24866  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24867 
24871  InfiniteLineKit & UnsetUserData(intptr_t in_index);
24872 
24877  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24878 
24882  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
24883 
24886  InfiniteLineKit & UnsetAllUserData();
24887 
24889  size_t ShowUserDataCount() const;
24890 
24894  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24895 
24900  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24901 
24906  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24907 };
24908 
24909 
24911 class HPS_API InfiniteLineKey : public GeometryKey
24912 {
24913 public:
24915  InfiniteLineKey();
24916 
24920  explicit InfiniteLineKey(Key const & in_that);
24921 
24924  InfiniteLineKey(InfiniteLineKey const & in_that);
24925 
24929  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
24930 
24934  InfiniteLineKey(InfiniteLineKey && in_that);
24935 
24939  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
24940 
24941  ~InfiniteLineKey();
24942 
24943  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
24944 
24947  void Consume(InfiniteLineKit & in_kit);
24948 
24951  void Set(InfiniteLineKit const & in_kit);
24952 
24955  void Show(InfiniteLineKit & out_kit) const;
24956 
24957 
24961  InfiniteLineKey & SetFirst(Point const & in_first);
24962 
24966  InfiniteLineKey & SetSecond(Point const & in_second);
24967 
24971  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
24972 
24973 
24977  bool ShowFirst(Point & out_first) const;
24978 
24982  bool ShowSecond(Point & out_second) const;
24983 
24987  bool ShowType(InfiniteLine::Type & out_type) const;
24988 };
24989 
24990 
24991 
24995 class HPS_API SpotlightKit : public Object
24996 {
24997 public:
24999  SpotlightKit();
25000 
25003  SpotlightKit(SpotlightKit const & in_kit);
25004 
25008  SpotlightKit(SpotlightKit && in_that);
25009 
25013  SpotlightKit & operator=(SpotlightKit && in_that);
25014 
25015  virtual ~SpotlightKit();
25016 
25017  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
25018 
25022  static SpotlightKit GetDefault();
25023 
25026  void Consume(SpotlightKit & in_kit);
25027 
25030  void Set(SpotlightKit const & in_kit);
25031 
25034  void Show(SpotlightKit & out_kit) const;
25035 
25039  SpotlightKit & operator=(SpotlightKit const & in_kit);
25040 
25043  bool Empty() const;
25044 
25048  bool Equals(SpotlightKit const & in_kit) const;
25049 
25053  bool operator==(SpotlightKit const & in_kit) const;
25054 
25058  bool operator!=(SpotlightKit const & in_kit) const;
25059 
25060 
25067  SpotlightKit & SetPriority(int in_priority);
25068 
25074  SpotlightKit & SetPosition(HPS::Point const & in_position);
25075 
25081  SpotlightKit & SetTarget(HPS::Point const & in_target);
25082 
25086  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
25087 
25091  SpotlightKit & SetColorByIndex(float in_index);
25092 
25099 
25106 
25112  SpotlightKit & SetConcentration(float in_concentration);
25113 
25119  SpotlightKit & SetCameraRelative(bool in_state);
25120 
25121 
25124  SpotlightKit & UnsetPriority();
25125 
25128  SpotlightKit & UnsetPosition();
25129 
25132  SpotlightKit & UnsetTarget();
25133 
25136  SpotlightKit & UnsetColor();
25137 
25140  SpotlightKit & UnsetOuterCone();
25141 
25144  SpotlightKit & UnsetInnerCone();
25145 
25148  SpotlightKit & UnsetConcentration();
25149 
25152  SpotlightKit & UnsetCameraRelative();
25153 
25156  SpotlightKit & UnsetEverything();
25157 
25158 
25162  bool ShowPriority(int & out_priority) const;
25163 
25167  bool ShowPosition(HPS::Point & out_position) const;
25168 
25172  bool ShowTarget(HPS::Point & out_target) const;
25173 
25179  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25180 
25185  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25186 
25191  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25192 
25196  bool ShowConcentration(float & out_concentration) const;
25197 
25201  bool ShowCameraRelative(bool & out_state) const;
25202 
25208  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25209 
25214  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25215 
25220  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25221 
25225  SpotlightKit & UnsetUserData(intptr_t in_index);
25226 
25231  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25232 
25236  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
25237 
25240  SpotlightKit & UnsetAllUserData();
25241 
25243  size_t ShowUserDataCount() const;
25244 
25248  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25249 
25254  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25255 
25260  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25261 };
25262 
25263 
25265 class HPS_API SpotlightKey : public GeometryKey
25266 {
25267 public:
25269  SpotlightKey();
25270 
25274  explicit SpotlightKey(Key const & in_that);
25275 
25278  SpotlightKey(SpotlightKey const & in_that);
25279 
25283  SpotlightKey & operator=(SpotlightKey const & in_that);
25284 
25288  SpotlightKey(SpotlightKey && in_that);
25289 
25293  SpotlightKey & operator=(SpotlightKey && in_that);
25294 
25295  ~SpotlightKey();
25296 
25297  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
25298 
25301  void Consume(SpotlightKit & in_kit);
25302 
25305  void Set(SpotlightKit const & in_kit);
25306 
25309  void Show(SpotlightKit & out_kit) const;
25310 
25311 
25317  SpotlightKey & SetPosition(HPS::Point const & in_position);
25318 
25324  SpotlightKey & SetTarget(HPS::Point const & in_target);
25325 
25329  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
25330 
25334  SpotlightKey & SetColorByIndex(float in_index);
25335 
25342 
25349 
25355  SpotlightKey & SetConcentration(float in_concentration);
25356 
25362  SpotlightKey & SetCameraRelative(bool in_state);
25363 
25364 
25367  SpotlightKey & UnsetColor();
25368 
25369 
25373  bool ShowPosition(HPS::Point & out_position) const;
25374 
25378  bool ShowTarget(HPS::Point & out_target) const;
25379 
25385  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25386 
25391  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
25392 
25397  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
25398 
25402  bool ShowConcentration(float & out_concentration) const;
25403 
25407  bool ShowCameraRelative(bool & out_state) const;
25408 };
25409 
25410 
25411 
25413 class HPS_API NURBSCurveKit : public Object
25414 {
25415 public:
25417  NURBSCurveKit();
25418 
25421  NURBSCurveKit(NURBSCurveKit const & in_kit);
25422 
25426  NURBSCurveKit(NURBSCurveKit && in_that);
25427 
25431  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
25432 
25433  virtual ~NURBSCurveKit();
25434 
25435  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
25436 
25439  void Consume(NURBSCurveKit & in_kit);
25440 
25443  void Set(NURBSCurveKit const & in_kit);
25444 
25447  void Show(NURBSCurveKit & out_kit) const;
25448 
25452  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
25453 
25456  bool Empty() const;
25457 
25461  bool Equals(NURBSCurveKit const & in_kit) const;
25462 
25466  bool operator==(NURBSCurveKit const & in_kit) const;
25467 
25471  bool operator!=(NURBSCurveKit const & in_kit) const;
25472 
25475  size_t GetPointCount() const;
25476 
25483  NURBSCurveKit & SetPriority(int in_priority);
25484 
25487  NURBSCurveKit & UnsetPriority();
25488 
25492  bool ShowPriority(int & out_priority) const;
25493 
25497  NURBSCurveKit & SetDegree(size_t in_degree);
25498 
25502  NURBSCurveKit & SetPoints(PointArray const & in_points);
25503 
25508  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
25509 
25513  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
25514 
25519  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
25520 
25524  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
25525 
25530  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
25531 
25536  NURBSCurveKit & SetParameters(float in_start, float in_end);
25537 
25538 
25541  NURBSCurveKit & UnsetDegree();
25542 
25545  NURBSCurveKit & UnsetPoints();
25546 
25549  NURBSCurveKit & UnsetWeights();
25550 
25553  NURBSCurveKit & UnsetKnots();
25554 
25557  NURBSCurveKit & UnsetParameters();
25558 
25561  NURBSCurveKit & UnsetEverything();
25562 
25563 
25567  bool ShowDegree(size_t & out_degree) const;
25568 
25572  bool ShowPoints(PointArray & out_points) const;
25573 
25579  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25580 
25585  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25586 
25592  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25593 
25597  bool ShowWeights(FloatArray & out_weights) const;
25598 
25602  bool ShowKnots(FloatArray & out_knots) const;
25603 
25608  bool ShowParameters(float & out_start, float & out_end) const;
25609 
25610 
25617  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25618 
25624  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25625 
25632  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25633 
25640  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25641 
25648  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25649 
25650 
25658  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25659 
25666  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25667 
25675  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25676 
25683  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25684 
25691  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25692 
25693 
25699  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25700 
25705  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25706 
25712  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25713 
25720  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25721 
25728  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25729 
25735  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25736 
25741  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25742 
25747  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25748 
25752  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25753 
25758  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25759 
25763  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25764 
25767  NURBSCurveKit & UnsetAllUserData();
25768 
25770  size_t ShowUserDataCount() const;
25771 
25775  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25776 
25781  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25782 
25787  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25788 };
25789 
25790 
25792 class HPS_API NURBSCurveKey : public GeometryKey
25793 {
25794 public:
25796  NURBSCurveKey();
25797 
25801  explicit NURBSCurveKey(Key const & in_that);
25802 
25805  NURBSCurveKey(NURBSCurveKey const & in_that);
25806 
25810  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
25811 
25815  NURBSCurveKey(NURBSCurveKey && in_that);
25816 
25820  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
25821 
25822  ~NURBSCurveKey();
25823 
25824  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
25825 
25828  void Consume(NURBSCurveKit & in_kit);
25829 
25832  void Set(NURBSCurveKit const & in_kit);
25833 
25836  void Show(NURBSCurveKit & out_kit) const;
25837 
25840  size_t GetPointCount() const;
25841 
25846  NURBSCurveKey & SetParameters(float in_start, float in_end);
25847 
25851  bool ShowDegree(size_t & out_degree) const;
25852 
25856  bool ShowPoints(PointArray & out_points) const;
25857 
25863  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25864 
25869  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25870 
25876  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25877 
25881  bool ShowWeights(FloatArray & out_weights) const;
25882 
25886  bool ShowKnots(FloatArray & out_knots) const;
25887 
25892  bool ShowParameters(float & out_start, float & out_end) const;
25893 
25894 
25902  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25903 
25910  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25911 
25912 
25921  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25922 
25930  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25931 
25932 
25940  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25941 
25948  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25949 };
25950 
25951 
25952 
25954 class HPS_API NURBSSurfaceKit : public Object
25955 {
25956 public:
25958  NURBSSurfaceKit();
25959 
25962  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
25963 
25967  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
25968 
25972  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
25973 
25974  virtual ~NURBSSurfaceKit();
25975 
25976  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
25977 
25980  void Consume(NURBSSurfaceKit & in_kit);
25981 
25984  void Set(NURBSSurfaceKit const & in_kit);
25985 
25988  void Show(NURBSSurfaceKit & out_kit) const;
25989 
25993  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
25994 
25997  bool Empty() const;
25998 
26002  bool Equals(NURBSSurfaceKit const & in_kit) const;
26003 
26007  bool operator==(NURBSSurfaceKit const & in_kit) const;
26008 
26012  bool operator!=(NURBSSurfaceKit const & in_kit) const;
26013 
26016  size_t GetPointCount() const;
26017 
26024  NURBSSurfaceKit & SetPriority(int in_priority);
26025 
26028  NURBSSurfaceKit & UnsetPriority();
26029 
26033  bool ShowPriority(int & out_priority) const;
26034 
26038  NURBSSurfaceKit & SetUDegree(size_t in_degree);
26039 
26043  NURBSSurfaceKit & SetVDegree(size_t in_degree);
26044 
26048  NURBSSurfaceKit & SetUCount(size_t in_count);
26049 
26053  NURBSSurfaceKit & SetVCount(size_t in_count);
26054 
26058  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
26059 
26064  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
26065 
26070  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
26071 
26077  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
26078 
26083  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
26084 
26090  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
26091 
26096  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
26097 
26103  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
26104 
26108  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
26109 
26114  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
26115 
26116 
26119  NURBSSurfaceKit & UnsetUDegree();
26120 
26123  NURBSSurfaceKit & UnsetVDegree();
26124 
26127  NURBSSurfaceKit & UnsetUCount();
26128 
26131  NURBSSurfaceKit & UnsetVCount();
26132 
26135  NURBSSurfaceKit & UnsetPoints();
26136 
26139  NURBSSurfaceKit & UnsetWeights();
26140 
26143  NURBSSurfaceKit & UnsetUKnots();
26144 
26147  NURBSSurfaceKit & UnsetVKnots();
26148 
26151  NURBSSurfaceKit & UnsetTrims();
26152 
26155  NURBSSurfaceKit & UnsetEverything();
26156 
26157 
26161  bool ShowUDegree(size_t & out_degree) const;
26162 
26166  bool ShowVDegree(size_t & out_degree) const;
26167 
26171  bool ShowUCount(size_t & out_count) const;
26172 
26176  bool ShowVCount(size_t & out_count) const;
26177 
26181  bool ShowPoints(PointArray & out_points) const;
26182 
26188  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26189 
26194  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26195 
26201  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26202 
26206  bool ShowWeights(FloatArray & out_weights) const;
26207 
26211  bool ShowUKnots(FloatArray & out_knots) const;
26212 
26216  bool ShowVKnots(FloatArray & out_knots) const;
26217 
26221  bool ShowTrims(TrimKitArray & out_trims) const;
26222 
26223 
26230  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26231 
26237  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26238 
26245  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
26246 
26253  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26254 
26261  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26262 
26263 
26271  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
26272 
26279  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
26280 
26288  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
26289 
26296  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26297 
26304  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26305 
26306 
26313  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26314 
26320  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26321 
26328  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
26329 
26336  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26337 
26344  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26345 
26346 
26353  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
26354 
26360  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
26361 
26368  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
26369 
26376  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26377 
26384  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26385 
26391  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26392 
26397  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26398 
26403  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26404 
26408  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
26409 
26414  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26415 
26419  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
26420 
26423  NURBSSurfaceKit & UnsetAllUserData();
26424 
26426  size_t ShowUserDataCount() const;
26427 
26431  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26432 
26437  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26438 
26443  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26444 };
26445 
26446 
26448 class HPS_API NURBSSurfaceKey : public GeometryKey
26449 {
26450 public:
26452  NURBSSurfaceKey();
26453 
26457  explicit NURBSSurfaceKey(Key const & in_that);
26458 
26461  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
26462 
26466  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
26467 
26471  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
26472 
26476  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
26477 
26478  ~NURBSSurfaceKey();
26479 
26480  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
26481 
26484  void Consume(NURBSSurfaceKit & in_kit);
26485 
26488  void Set(NURBSSurfaceKit const & in_kit);
26489 
26492  void Show(NURBSSurfaceKit & out_kit) const;
26493 
26496  size_t GetPointCount() const;
26497 
26502  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
26503 
26507  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
26508 
26509 
26512  NURBSSurfaceKey & UnsetTrims();
26513 
26514 
26518  bool ShowUDegree(size_t & out_degree) const;
26519 
26523  bool ShowVDegree(size_t & out_degree) const;
26524 
26528  bool ShowUCount(size_t & out_count) const;
26529 
26533  bool ShowVCount(size_t & out_count) const;
26534 
26538  bool ShowPoints(PointArray & out_points) const;
26539 
26545  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26546 
26551  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26552 
26558  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26559 
26563  bool ShowWeights(FloatArray & out_weights) const;
26564 
26568  bool ShowUKnots(FloatArray & out_knots) const;
26569 
26573  bool ShowVKnots(FloatArray & out_knots) const;
26574 
26578  bool ShowTrims(TrimKitArray & out_trims) const;
26579 
26580 
26588  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26589 
26596  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26597 
26598 
26607  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
26608 
26616  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
26617 
26618 
26626  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26627 
26634  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26635 
26636 
26644  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
26645 
26652  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
26653 };
26654 
26655 
26656 
26658 class HPS_API TrimElement : public Object
26659 {
26660 public:
26662  TrimElement();
26663 
26666  TrimElement(TrimElement const & in_that);
26667 
26671  TrimElement(LineKit const & in_line);
26672 
26676  TrimElement(NURBSCurveKit const & in_curve);
26677 
26681  TrimElement(TrimElement && in_that);
26682 
26686  TrimElement & operator=(TrimElement && in_that);
26687 
26688  ~TrimElement();
26689 
26690  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
26691 
26694  void Set(TrimElement const & in_that);
26695 
26699  TrimElement & operator=(TrimElement const & in_that);
26700 
26704  bool Equals(TrimElement const & in_that) const;
26705 
26709  bool operator==(TrimElement const & in_that) const;
26710 
26714  bool operator!=(TrimElement const & in_that) const;
26715 
26716 
26720  void SetCurve(LineKit const & in_line);
26721 
26725  void SetCurve(NURBSCurveKit const & in_curve);
26726 
26732  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26733 };
26734 
26735 
26736 
26738 class HPS_API TrimKit : public Object
26739 {
26740 public:
26742  TrimKit();
26743 
26746  TrimKit(TrimKit const & in_kit);
26747 
26751  TrimKit(TrimKit && in_that);
26752 
26756  TrimKit & operator=(TrimKit && in_that);
26757 
26758  virtual ~TrimKit();
26759 
26760  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
26761 
26764  void Set(TrimKit const & in_kit);
26765 
26768  void Show(TrimKit & out_kit) const;
26769 
26773  TrimKit & operator=(TrimKit const & in_kit);
26774 
26777  bool Empty() const;
26778 
26782  bool Equals(TrimKit const & in_kit) const;
26783 
26787  bool operator==(TrimKit const & in_kit) const;
26788 
26792  bool operator!=(TrimKit const & in_kit) const;
26793 
26794 
26799  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
26800 
26804  TrimKit & SetShape(TrimElementArray const & in_shape);
26805 
26809  TrimKit & SetOperation(Trim::Operation in_operation);
26810 
26811 
26814  TrimKit & UnsetShape();
26815 
26818  TrimKit & UnsetOperation();
26819 
26822  TrimKit & UnsetEverything();
26823 
26824 
26828  bool ShowShape(TrimElementArray & out_shape) const;
26829 
26833  bool ShowOperation(Trim::Operation & out_operation) const;
26834 };
26835 
26836 
26837 
26839 class HPS_API EllipseKit : public Object
26840 {
26841 public:
26843  EllipseKit();
26844 
26847  EllipseKit(EllipseKit const & in_kit);
26848 
26852  EllipseKit(EllipseKit && in_that);
26853 
26857  EllipseKit & operator=(EllipseKit && in_that);
26858 
26859  virtual ~EllipseKit();
26860 
26861  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
26862 
26865  void Consume(EllipseKit & in_kit);
26866 
26869  void Set(EllipseKit const & in_kit);
26870 
26873  void Show(EllipseKit & out_kit) const;
26874 
26878  EllipseKit & operator=(EllipseKit const & in_kit);
26879 
26882  bool Empty() const;
26883 
26887  bool Equals(EllipseKit const & in_kit) const;
26888 
26892  bool operator==(EllipseKit const & in_kit) const;
26893 
26897  bool operator!=(EllipseKit const & in_kit) const;
26898 
26905  EllipseKit & SetPriority(int in_priority);
26906 
26909  EllipseKit & UnsetPriority();
26910 
26914  bool ShowPriority(int & out_priority) const;
26915 
26916 
26920  EllipseKit & SetCenter(Point const & in_center);
26921 
26925  EllipseKit & SetMajor(Point const & in_major);
26926 
26930  EllipseKit & SetMinor(Point const & in_minor);
26931 
26932 
26935  EllipseKit & UnsetCenter();
26936 
26939  EllipseKit & UnsetMajor();
26940 
26943  EllipseKit & UnsetMinor();
26944 
26947  EllipseKit & UnsetEverything();
26948 
26949 
26953  bool ShowCenter(Point & out_center) const;
26954 
26958  bool ShowMajor(Point & out_major) const;
26959 
26963  bool ShowMinor(Point & out_minor) const;
26964 
26970  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26971 
26976  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26977 
26982  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26983 
26987  EllipseKit & UnsetUserData(intptr_t in_index);
26988 
26993  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26994 
26998  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
26999 
27002  EllipseKit & UnsetAllUserData();
27003 
27005  size_t ShowUserDataCount() const;
27006 
27010  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27011 
27016  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27017 
27022  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27023 };
27024 
27025 
27026 
27028 class HPS_API EllipseKey : public GeometryKey
27029 {
27030 public:
27032  EllipseKey();
27033 
27037  explicit EllipseKey(Key const & in_that);
27038 
27041  EllipseKey(EllipseKey const & in_that);
27042 
27046  EllipseKey & operator=(EllipseKey const & other);
27047 
27051  EllipseKey(EllipseKey && in_that);
27052 
27056  EllipseKey & operator=(EllipseKey && in_that);
27057 
27058  ~EllipseKey();
27059 
27060  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
27061 
27064  void Consume(EllipseKit & in_kit);
27065 
27068  void Set(EllipseKit const & in_kit);
27069 
27072  void Show(EllipseKit & out_kit) const;
27073 
27074 
27078  EllipseKey & SetCenter(Point const & in_center);
27079 
27083  EllipseKey & SetMajor(Point const & in_major);
27084 
27088  EllipseKey & SetMinor(Point const & in_minor);
27089 
27090 
27094  bool ShowCenter(Point & out_center) const;
27095 
27099  bool ShowMajor(Point & out_major) const;
27100 
27104  bool ShowMinor(Point & out_minor) const;
27105 };
27106 
27107 
27108 
27110 class HPS_API EllipticalArcKit : public Object
27111 {
27112 public:
27114  EllipticalArcKit();
27115 
27118  EllipticalArcKit(EllipticalArcKit const & in_kit);
27119 
27123  EllipticalArcKit(EllipticalArcKit && in_that);
27124 
27128  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
27129 
27130  virtual ~EllipticalArcKit();
27131 
27132  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
27133 
27136  void Consume(EllipticalArcKit & in_kit);
27137 
27140  void Set(EllipticalArcKit const & in_kit);
27141 
27144  void Show(EllipticalArcKit & out_kit) const;
27145 
27149  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
27150 
27153  bool Empty() const;
27154 
27158  bool Equals(EllipticalArcKit const & in_kit) const;
27159 
27163  bool operator==(EllipticalArcKit const & in_kit) const;
27164 
27168  bool operator!=(EllipticalArcKit const & in_kit) const;
27169 
27176  EllipticalArcKit & SetPriority(int in_priority);
27177 
27180  EllipticalArcKit & UnsetPriority();
27181 
27185  bool ShowPriority(int & out_priority) const;
27186 
27187 
27191  EllipticalArcKit & SetCenter(Point const & in_center);
27192 
27196  EllipticalArcKit & SetMajor(Point const & in_major);
27197 
27201  EllipticalArcKit & SetMinor(Point const & in_minor);
27202 
27210  EllipticalArcKit & SetStart(float in_start);
27211 
27219  EllipticalArcKit & SetEnd(float in_end);
27220 
27221 
27224  EllipticalArcKit & UnsetCenter();
27225 
27228  EllipticalArcKit & UnsetMajor();
27229 
27232  EllipticalArcKit & UnsetMinor();
27233 
27236  EllipticalArcKit & UnsetStart();
27237 
27240  EllipticalArcKit & UnsetEnd();
27241 
27244  EllipticalArcKit & UnsetEverything();
27245 
27246 
27250  bool ShowCenter(Point & out_center) const;
27251 
27255  bool ShowMajor(Point & out_major) const;
27256 
27260  bool ShowMinor(Point & out_minor) const;
27261 
27265  bool ShowStart(float & out_start) const;
27266 
27270  bool ShowEnd(float & out_end) const;
27271 
27277  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27278 
27283  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27284 
27289  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27290 
27294  EllipticalArcKit & UnsetUserData(intptr_t in_index);
27295 
27300  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27301 
27305  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27306 
27309  EllipticalArcKit & UnsetAllUserData();
27310 
27312  size_t ShowUserDataCount() const;
27313 
27317  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27318 
27323  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27324 
27329  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27330 };
27331 
27332 
27334 class HPS_API EllipticalArcKey : public GeometryKey
27335 {
27336 public:
27338  EllipticalArcKey();
27339 
27343  explicit EllipticalArcKey(Key const & in_that);
27344 
27347  EllipticalArcKey(EllipticalArcKey const & in_that);
27348 
27352  EllipticalArcKey & operator=(EllipticalArcKey const & other);
27353 
27357  EllipticalArcKey(EllipticalArcKey && in_that);
27358 
27362  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
27363 
27364  ~EllipticalArcKey();
27365 
27366  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
27367 
27368 
27371  void Consume(EllipticalArcKit & in_kit);
27372 
27375  void Set(EllipticalArcKit const & in_kit);
27376 
27379  void Show(EllipticalArcKit & out_kit) const;
27380 
27381 
27385  EllipticalArcKey & SetCenter(Point const & in_center);
27386 
27390  EllipticalArcKey & SetMajor(Point const & in_major);
27391 
27395  EllipticalArcKey & SetMinor(Point const & in_minor);
27396 
27404  EllipticalArcKey & SetStart(float in_start);
27405 
27413  EllipticalArcKey & SetEnd(float in_end);
27414 
27415 
27419  bool ShowCenter(Point & out_center) const;
27420 
27424  bool ShowMajor(Point & out_major) const;
27425 
27429  bool ShowMinor(Point & out_minor) const;
27430 
27434  bool ShowStart(float & out_start) const;
27435 
27439  bool ShowEnd(float & out_end) const;
27440 };
27441 
27442 
27443 
27445 class HPS_API TextKit : public Object
27446 {
27447 public:
27449  TextKit();
27450 
27453  TextKit(TextKit const & in_kit);
27454 
27458  TextKit(TextKit && in_that);
27459 
27463  TextKit & operator=(TextKit && in_that);
27464 
27465  virtual ~TextKit();
27466 
27467  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
27468 
27471  void Consume(TextKit & in_kit);
27472 
27475  void Set(TextKit const & in_kit);
27476 
27479  void Show(TextKit & out_kit) const;
27480 
27484  TextKit & operator=(TextKit const & in_kit);
27485 
27488  bool Empty() const;
27489 
27493  bool Equals(TextKit const & in_kit) const;
27494 
27498  bool operator==(TextKit const & in_kit) const;
27499 
27503  bool operator!=(TextKit const & in_kit) const;
27504 
27511  TextKit & SetPriority(int in_priority);
27512 
27515  TextKit & UnsetPriority();
27516 
27520  bool ShowPriority(int & out_priority) const;
27521 
27525  TextKit & SetPosition(Point const & in_position);
27526 
27530  TextKit & SetText(char const * in_string);
27531 
27535  TextKit & SetColor(RGBAColor const & in_rgba_color);
27536 
27540  TextKit & SetColorByIndex(float in_index);
27541 
27545  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
27546 
27553 
27557  TextKit & SetBold(bool in_state);
27558 
27562  TextKit & SetItalic(bool in_state);
27563 
27567  TextKit & SetOverline(bool in_state);
27568 
27572  TextKit & SetStrikethrough(bool in_state);
27573 
27577  TextKit & SetUnderline(bool in_state);
27578 
27583  TextKit & SetSlant(float in_angle);
27584 
27588  TextKit & SetLineSpacing(float in_multiplier);
27589 
27595  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27596 
27600  TextKit & SetRotation(float in_angle);
27601 
27607  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27608 
27613  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27614 
27621  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27622 
27628  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27629 
27638  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27639 
27647  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27648 
27653  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
27654 
27660  TextKit & SetFont(char const * in_name);
27661 
27665  TextKit & SetTransform(Text::Transform in_trans);
27666 
27670  TextKit & SetRenderer(Text::Renderer in_rend);
27671 
27675  TextKit & SetPreference(Text::Preference in_pref);
27676 
27683  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27684 
27688  TextKit & SetPath(Vector const & in_path);
27689 
27695  TextKit & SetSpacing(float in_multiplier);
27696 
27697 
27700  TextKit & UnsetPosition();
27701 
27704  TextKit & UnsetText();
27705 
27708  TextKit & UnsetColor();
27709 
27712  TextKit & UnsetModellingMatrix();
27713 
27716  TextKit & UnsetAlignment();
27717 
27720  TextKit & UnsetBold();
27721 
27724  TextKit & UnsetItalic();
27725 
27728  TextKit & UnsetOverline();
27729 
27732  TextKit & UnsetStrikethrough();
27733 
27736  TextKit & UnsetUnderline();
27737 
27740  TextKit & UnsetSlant();
27741 
27744  TextKit & UnsetLineSpacing();
27745 
27748  TextKit & UnsetRotation();
27749 
27752  TextKit & UnsetExtraSpace();
27753 
27756  TextKit & UnsetGreeking();
27757 
27760  TextKit & UnsetSizeTolerance();
27761 
27764  TextKit & UnsetSize();
27765 
27768  TextKit & UnsetFont();
27769 
27772  TextKit & UnsetTransform();
27773 
27776  TextKit & UnsetRenderer();
27777 
27780  TextKit & UnsetPreference();
27781 
27784  TextKit & UnsetPath();
27785 
27788  TextKit & UnsetSpacing();
27789 
27792  TextKit & UnsetEverything();
27793 
27794 
27798  bool ShowPosition(Point & out_position) const;
27799 
27803  bool ShowText(UTF8 & out_string) const;
27804 
27810  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27811 
27815  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27816 
27822  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27823 
27827  bool ShowBold(bool & out_state) const;
27828 
27832  bool ShowItalic(bool & out_state) const;
27833 
27837  bool ShowOverline(bool & out_state) const;
27838 
27842  bool ShowStrikethrough(bool & out_state) const;
27843 
27847  bool ShowUnderline(bool & out_state) const;
27848 
27852  bool ShowSlant(float & out_angle) const;
27853 
27857  bool ShowLineSpacing(float & out_multiplier) const;
27858 
27863  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27864 
27870  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27871 
27878  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27879 
27885  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27886 
27891  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27892 
27896  bool ShowFont(UTF8 & out_name) const;
27897 
27901  bool ShowTransform(Text::Transform & out_trans) const;
27902 
27906  bool ShowRenderer(Text::Renderer & out_renderer) const;
27907 
27914  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
27915 
27919  bool ShowPath(Vector & out_path) const;
27920 
27924  bool ShowSpacing(float & out_multiplier) const;
27925 
27926 
27934  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27935 
27942  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
27943 
27950  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27951 
27960  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
27961 
27974  TextKit & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
27975 
27989  TextKit & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
27990 
27996  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27997 
28000  TextKit & UnsetRegion();
28001 
28006  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28007 
28012  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28013 
28017  TextKit & UnsetUserData(intptr_t in_index);
28018 
28023  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28024 
28028  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
28029 
28032  TextKit & UnsetAllUserData();
28033 
28035  size_t ShowUserDataCount() const;
28036 
28040  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28041 
28046  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28047 
28052  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28053 };
28054 
28055 
28057 class HPS_API TextKey : public GeometryKey
28058 {
28059 public:
28061  TextKey();
28062 
28066  explicit TextKey(Key const & in_that);
28067 
28070  TextKey(TextKey const & in_that);
28071 
28075  TextKey & operator=(TextKey const & other);
28076 
28080  TextKey(TextKey && in_that);
28081 
28085  TextKey & operator=(TextKey && in_that);
28086 
28087  ~TextKey();
28088 
28089  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
28090 
28093  void Consume(TextKit & in_kit);
28094 
28097  void Set(TextKit const & in_kit);
28098 
28101  void Show(TextKit & out_kit) const;
28102 
28105  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
28106 
28110  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
28111 
28115  TextKey & SetPosition(Point const & in_position);
28116 
28120  TextKey & SetText(char const * in_string);
28121 
28125  TextKey & SetColor(RGBAColor const & in_rgba_color);
28126 
28130  TextKey & SetColorByIndex(float in_index);
28131 
28135  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
28136 
28143 
28147  TextKey & SetBold(bool in_state);
28148 
28152  TextKey & SetItalic(bool in_state);
28153 
28157  TextKey & SetOverline(bool in_state);
28158 
28162  TextKey & SetStrikethrough(bool in_state);
28163 
28167  TextKey & SetUnderline(bool in_state);
28168 
28173  TextKey & SetSlant(float in_angle);
28174 
28179  TextKey & SetLineSpacing(float in_multiplier);
28180 
28186  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
28187 
28191  TextKey & SetRotation(float in_angle);
28192 
28198  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
28199 
28204  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
28205 
28212  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28213 
28219  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
28220 
28229  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
28230 
28238  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
28239 
28244  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
28245 
28251  TextKey & SetFont(char const * in_name);
28252 
28256  TextKey & SetTransform(Text::Transform in_transform);
28257 
28261  TextKey & SetRenderer(Text::Renderer in_renderer);
28262 
28266  TextKey & SetPreference(Text::Preference in_preference);
28267 
28275  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
28276 
28281  TextKey & SetPath(Vector const & in_path);
28282 
28288  TextKey & SetSpacing(float in_multiplier);
28289 
28302  TextKey & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
28303 
28317  TextKey & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
28318 
28319 
28322  TextKey & UnsetColor();
28323 
28326  TextKey & UnsetModellingMatrix();
28327 
28330  TextKey & UnsetAlignment();
28331 
28334  TextKey & UnsetBold();
28335 
28338  TextKey & UnsetItalic();
28339 
28342  TextKey & UnsetOverline();
28343 
28346  TextKey & UnsetStrikethrough();
28347 
28350  TextKey & UnsetUnderline();
28351 
28354  TextKey & UnsetSlant();
28355 
28358  TextKey & UnsetLineSpacing();
28359 
28362  TextKey & UnsetRotation();
28363 
28366  TextKey & UnsetExtraSpace();
28367 
28370  TextKey & UnsetGreeking();
28371 
28374  TextKey & UnsetSizeTolerance();
28375 
28378  TextKey & UnsetSize();
28379 
28382  TextKey & UnsetFont();
28383 
28386  TextKey & UnsetTransform();
28387 
28390  TextKey & UnsetRenderer();
28391 
28394  TextKey & UnsetPreference();
28395 
28398  TextKey & UnsetPath();
28399 
28402  TextKey & UnsetSpacing();
28403 
28406  TextKey & UnsetRegion();
28407 
28410  TextKey & UnsetEverything();
28411 
28412 
28416  bool ShowPosition(Point & out_position) const;
28417 
28421  bool ShowText(UTF8 & out_string) const;
28422 
28428  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28429 
28433  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
28434 
28440  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
28441 
28445  bool ShowBold(bool & out_state) const;
28446 
28450  bool ShowItalic(bool & out_state) const;
28451 
28455  bool ShowOverline(bool & out_state) const;
28456 
28460  bool ShowStrikethrough(bool & out_state) const;
28461 
28465  bool ShowUnderline(bool & out_state) const;
28466 
28470  bool ShowSlant(float & out_angle) const;
28471 
28475  bool ShowLineSpacing(float & out_multiplier) const;
28476 
28481  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
28482 
28488  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
28489 
28496  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
28497 
28503  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
28504 
28509  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
28510 
28514  bool ShowFont(UTF8 & out_name) const;
28515 
28519  bool ShowTransform(Text::Transform & out_trans) const;
28520 
28524  bool ShowRenderer(Text::Renderer & out_renderer) const;
28525 
28532  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
28533 
28537  bool ShowPath(Vector & out_path) const;
28538 
28542  bool ShowSpacing(float & out_multiplier) const;
28543 
28552  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
28553 
28554 
28562  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28563 
28570  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
28571 
28578  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
28579 };
28580 
28581 
28583 class HPS_API ShellOptimizationOptionsKit : public Object
28584 {
28585 public:
28588 
28592 
28597 
28598  virtual ~ShellOptimizationOptionsKit();
28599 
28600  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
28601 
28604  void Consume(ShellOptimizationOptionsKit & in_kit);
28605 
28608  void Set(ShellOptimizationOptionsKit const & in_kit);
28609 
28612  void Show(ShellOptimizationOptionsKit & out_kit) const;
28613 
28617  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
28618 
28623 
28626  bool Empty() const;
28627 
28631  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
28632 
28636  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
28637 
28641  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
28642 
28646  static ShellOptimizationOptionsKit GetDefault();
28647 
28648 
28652  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
28653 
28658  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
28659 
28664  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
28665 
28670  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
28671 
28672 
28675  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28676 
28679  ShellOptimizationOptionsKit & UnsetTolerance();
28680 
28683  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28684 
28687  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28688 
28691  ShellOptimizationOptionsKit & UnsetEverything();
28692 
28693 
28697  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28698 
28703  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28704 
28708  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28709 
28714  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28715 };
28716 
28717 
28721 class HPS_API ShellRelationOptionsKit : public Object
28722 {
28723 public:
28726 
28730 
28735 
28739  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28740 
28741  virtual ~ShellRelationOptionsKit();
28742 
28743  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
28744 
28748  static ShellRelationOptionsKit GetDefault();
28749 
28752  void Consume(ShellRelationOptionsKit & in_kit);
28753 
28756  void Set(ShellRelationOptionsKit const & in_kit);
28757 
28760  void Show(ShellRelationOptionsKit & out_kit) const;
28761 
28765  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28766 
28769  bool Empty() const;
28770 
28774  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28775 
28779  bool operator==(ShellRelationOptionsKit const & in_kit) const;
28780 
28784  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
28785 
28786 
28790  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
28791 
28795  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
28796 
28801  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
28802 
28806  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
28807 
28808 
28811  ShellRelationOptionsKit & UnsetTolerance();
28812 
28815  ShellRelationOptionsKit & UnsetTest();
28816 
28819  ShellRelationOptionsKit & UnsetTreeContext();
28820 
28823  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
28824 
28827  ShellRelationOptionsKit & UnsetEverything();
28828 
28829 
28833  bool ShowTolerance(float & out_tolerance) const;
28834 
28838  bool ShowTest(Shell::RelationTest & out_test) const;
28839 
28843  bool ShowTreeContext(TreeContext & out_tree_context) const;
28844 
28848  bool ShowNearestFaceCalculation(bool & out_state) const;
28849 };
28850 
28852 class HPS_API ShellRelationResultsKit : public Object
28853 {
28854 public:
28857 
28861 
28866 
28870  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
28871 
28872  virtual ~ShellRelationResultsKit();
28873 
28874  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
28875 
28878  void Consume(ShellRelationResultsKit & in_kit);
28879 
28882  void Set(ShellRelationResultsKit const & in_kit);
28883 
28886  void Show(ShellRelationResultsKit & out_kit) const;
28887 
28891  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
28892 
28895  bool Empty() const;
28896 
28900  bool Equals(ShellRelationResultsKit const & in_kit) const;
28901 
28905  bool operator==(ShellRelationResultsKit const & in_kit) const;
28906 
28910  bool operator!=(ShellRelationResultsKit const & in_kit) const;
28911 
28912 
28916  bool ShowRelations(ShellRelationArray & out_results) const;
28917 
28921  bool ShowNearestFaces(SizeTArray & out_faces) const;
28922 
28926  bool ShowDistances(FloatArray & out_distances) const;
28927 };
28928 
28929 
28931 class HPS_API ShellKit : public Object
28932 {
28933 public:
28935  ShellKit();
28936 
28939  ShellKit(ShellKit const & in_kit);
28940 
28944  ShellKit(ShellKit && in_that);
28945 
28949  ShellKit & operator=(ShellKit && in_that);
28950 
28951  virtual ~ShellKit();
28952 
28953  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
28954 
28957  void Consume(ShellKit & in_kit);
28958 
28961  void Set(ShellKit const & in_kit);
28962 
28965  void Show(ShellKit & out_kit) const;
28966 
28969  size_t GetPointCount() const;
28970 
28973  size_t GetFaceCount() const;
28974 
28978  ShellKit & operator=(ShellKit const & in_kit);
28979 
28982  bool Empty() const;
28983 
28987  bool Equals(ShellKit const & in_kit) const;
28988 
28992  bool operator==(ShellKit const & in_kit) const;
28993 
28997  bool operator!=(ShellKit const & in_kit) const;
28998 
29005  ShellKit & SetPriority(int in_priority);
29006 
29009  ShellKit & UnsetPriority();
29010 
29014  bool ShowPriority(int & out_priority) const;
29015 
29016 
29017 
29021  ShellKit & SetPoints(PointArray const & in_points);
29022 
29027  ShellKit & SetPoints(size_t in_count, Point const in_points []);
29028 
29032  ShellKit & SetFacelist(IntArray const & in_facelist);
29033 
29038  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
29039 
29043  ShellKit & SetTristrips(IntArray const & in_tristrips);
29044 
29049  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
29050 
29053  ShellKit & UnsetPoints();
29054 
29057  ShellKit & UnsetFacelist();
29058 
29061  ShellKit & UnsetTristrips();
29062 
29065  ShellKit & UnsetEverything();
29066 
29070  bool ShowPoints(PointArray & out_points) const;
29071 
29077  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29078 
29083  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29084 
29090  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29091 
29095  bool ShowFacelist(IntArray & out_facelist) const;
29096 
29100  bool ShowTristrips(IntArray & out_tristrips) const;
29101 
29107  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
29108 
29109 
29116  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29117 
29123  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29124 
29131  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29132 
29139  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29140 
29147  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29148 
29155  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29156 
29162  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29163 
29164 
29171  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29172 
29178  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29179 
29186  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29187 
29194  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29195 
29202  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29203 
29210  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29211 
29217  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29218 
29219 
29226  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29227 
29233  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29234 
29241  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29242 
29249  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29250 
29257  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29258 
29265  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29266 
29272  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29273 
29274 
29280  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29281 
29286  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29287 
29293  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29294 
29300  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29301 
29306  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29307 
29313  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29314 
29319  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29320 
29321 
29328  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29329 
29336  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29337 
29346  ShellKit & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
29347 
29355  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29356 
29357 
29363  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29364 
29369  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29370 
29376  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29377 
29383  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29384 
29389  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29390 
29396  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29397 
29402  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29403 
29404 
29407  ShellKit & UnsetMaterialMapping();
29408 
29409 
29412  ShellKit & UnsetVertexColors();
29413 
29418  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29419 
29423  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29424 
29425 
29429  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
29430 
29436  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29437 
29442  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29443 
29444 
29447  ShellKit & UnsetVertexNormals();
29448 
29453  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29454 
29458  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29459 
29460 
29463  ShellKit & UnsetVertexParameters();
29464 
29469  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29470 
29474  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29475 
29476 
29479  ShellKit & UnsetVertexVisibilities();
29480 
29485  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29486 
29490  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29491 
29492 
29495  ShellKit & UnsetVertexEverything();
29496 
29497 
29501  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29502 
29503 
29517  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29518  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29519 
29534  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29535  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29536 
29537 
29546  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29547 
29556  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29557 
29558 
29568  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29569 
29579  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29580 
29590  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29591 
29601  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29602 
29603 
29612  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29613 
29622  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
29623 
29624 
29625 
29631  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
29632 
29637  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
29638 
29644  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
29645 
29651  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
29652 
29657  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
29658 
29664  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
29665 
29670  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
29671 
29672 
29678  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
29679 
29684  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
29685 
29691  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
29692 
29698  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
29699 
29704  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
29705 
29711  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29712 
29717  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29718 
29719 
29725  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29726 
29731  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29732 
29738  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29739 
29745  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29746 
29751  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29752 
29758  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29759 
29764  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29765 
29766 
29772  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29773 
29778  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29779 
29785  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29786 
29792  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
29793 
29798  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
29799 
29805  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
29806 
29811  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
29812 
29813 
29816  ShellKit & UnsetFaceColors();
29817 
29822  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
29823 
29827  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
29828 
29829 
29832  ShellKit & UnsetFaceNormals();
29833 
29838  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
29839 
29843  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
29844 
29845 
29848  ShellKit & UnsetFaceVisibilities();
29849 
29854  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
29855 
29859  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
29860 
29861 
29864  ShellKit & UnsetFaceEverything();
29865 
29866 
29876  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29877 
29888  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29889 
29890 
29899  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29900 
29909  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
29910 
29911 
29920  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29921 
29930  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
29931 
29932 
29939  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
29940 
29946  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
29947 
29953  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
29954 
29960  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29961 
29967  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29968 
29969 
29976  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
29977 
29983  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
29984 
29990  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
29991 
30000  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30001 
30009  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30010 
30013  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30014 
30019  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30020 
30025  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30026 
30031  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30032 
30038  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30039 
30044  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30045 
30050  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30051 
30055  ShellKit & UnsetUserData(intptr_t in_index);
30056 
30061  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30062 
30066  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
30067 
30070  ShellKit & UnsetAllUserData();
30071 
30073  size_t ShowUserDataCount() const;
30074 
30078  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30079 
30084  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30085 
30090  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30091 };
30092 
30093 
30094 
30096 class HPS_API ShellKey : public GeometryKey
30097 {
30098 public:
30100  ShellKey();
30101 
30106  explicit ShellKey(Key const & in_that);
30107 
30110  ShellKey(ShellKey const & in_that);
30111 
30115  ShellKey & operator=(ShellKey const & other);
30116 
30120  ShellKey(ShellKey && in_that);
30121 
30125  ShellKey & operator=(ShellKey && in_that);
30126 
30127  ~ShellKey();
30128 
30129  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
30130 
30133  void Consume(ShellKit & in_kit);
30134 
30137  void Set(ShellKit const & in_kit);
30138 
30141  void Show(ShellKit & out_kit) const;
30142 
30145  size_t GetPointCount() const;
30146 
30149  size_t GetFaceCount() const;
30150 
30151 
30155  ShellKey & SetPoints(PointArray const & in_points);
30156 
30161  ShellKey & SetPoints(size_t in_count, Point const in_points []);
30162 
30166  ShellKey & SetFacelist(IntArray const & in_facelist);
30167 
30172  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
30173 
30177  ShellKey & SetTristrips(IntArray const & in_tristrips);
30178 
30183  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
30184 
30189  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
30190 
30193  ShellKey & UnsetPoints();
30194 
30197  ShellKey & UnsetFacelist();
30198 
30201  ShellKey & UnsetTristrips();
30202 
30205  ShellKey & UnsetMaterialMapping();
30206 
30209  ShellKey & UnsetEverything();
30210 
30214  bool ShowPoints(PointArray & out_points) const;
30215 
30221  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
30222 
30227  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
30228 
30234  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
30235 
30239  bool ShowFacelist(IntArray & out_facelist) const;
30240 
30244  bool ShowTristrips(IntArray & out_tristrips) const;
30245 
30249  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30250 
30251 
30258  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30259 
30266  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30267 
30274  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30275 
30282  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30283 
30290  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30291 
30298  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30299 
30305  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
30306 
30307 
30314  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30315 
30322  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30323 
30330  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30331 
30338  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
30339 
30346  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
30347 
30354  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30355 
30361  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
30362 
30363 
30370  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30371 
30378  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30379 
30386  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30387 
30394  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
30395 
30402  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
30403 
30410  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30411 
30417  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
30418 
30419 
30425  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30426 
30432  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30433 
30439  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30440 
30446  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30447 
30452  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30453 
30459  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30460 
30465  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30466 
30467 
30475  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30476 
30483  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30484 
30493  ShellKey & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
30494 
30502  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30503 
30504 
30510  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30511 
30517  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30518 
30524  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30525 
30531  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30532 
30537  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30538 
30544  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30545 
30550  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30551 
30552 
30555  ShellKey & UnsetVertexColors();
30556 
30561  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30562 
30566  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30567 
30568 
30572  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
30573 
30579  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
30580 
30585  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
30586 
30587 
30590  ShellKey & UnsetVertexNormals();
30591 
30596  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30597 
30601  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30602 
30603 
30606  ShellKey & UnsetVertexParameters();
30607 
30612  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30613 
30617  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30618 
30619 
30622  ShellKey & UnsetVertexVisibilities();
30623 
30628  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30629 
30633  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30634 
30635 
30638  ShellKey & UnsetVertexEverything();
30639 
30640 
30654  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30655  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30656 
30671  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
30672  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
30673 
30674 
30683  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30684 
30693  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
30694 
30695 
30705  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
30706 
30716  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30717 
30727  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
30728 
30738  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
30739 
30740 
30749  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30750 
30759  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30760 
30761 
30767  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30768 
30774  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30775 
30781  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30782 
30788  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30789 
30794  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30795 
30801  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30802 
30807  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30808 
30809 
30815  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30816 
30822  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30823 
30829  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30830 
30836  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30837 
30842  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30843 
30849  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30850 
30855  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30856 
30857 
30863  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30864 
30870  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30871 
30877  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30878 
30884  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30885 
30890  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30891 
30897  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30898 
30903  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30904 
30905 
30911  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30912 
30918  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30919 
30925  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30926 
30932  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
30933 
30938  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
30939 
30945  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
30946 
30951  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
30952 
30953 
30956  ShellKey & UnsetFaceColors();
30957 
30962  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
30963 
30967  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
30968 
30969 
30972  ShellKey & UnsetFaceNormals();
30973 
30978  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
30979 
30983  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
30984 
30985 
30988  ShellKey & UnsetFaceVisibilities();
30989 
30994  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
30995 
30999  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31000 
31001 
31004  ShellKey & UnsetFaceEverything();
31005 
31006 
31016  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31017 
31028  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31029 
31030 
31039  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31040 
31049  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31050 
31051 
31057  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
31058 
31065  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
31066 
31067 
31076  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31077 
31086  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31087 
31088 
31095  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
31096 
31102  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
31103 
31109  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
31110 
31116  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
31117 
31123  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
31124 
31125 
31132  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
31133 
31139  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
31140 
31146  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
31147 
31156  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
31157 
31165  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
31166 
31169  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
31170 
31175  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31176 
31181  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31182 
31187  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
31188 };
31189 
31190 
31191 
31193 class HPS_API MeshKit : public Object
31194 {
31195 public:
31197  MeshKit();
31198 
31201  MeshKit(MeshKit const & in_kit);
31202 
31206  MeshKit(MeshKit && in_that);
31207 
31211  MeshKit & operator=(MeshKit && in_that);
31212 
31213  virtual ~MeshKit();
31214 
31215  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
31216 
31219  void Consume(MeshKit & in_kit);
31220 
31223  void Set(MeshKit const & in_kit);
31224 
31227  void Show(MeshKit & out_kit) const;
31228 
31232  MeshKit & operator=(MeshKit const & in_kit);
31233 
31236  bool Empty() const;
31237 
31241  bool Equals(MeshKit const & in_kit) const;
31242 
31246  bool operator==(MeshKit const & in_kit) const;
31247 
31251  bool operator!=(MeshKit const & in_kit) const;
31252 
31255  size_t GetPointCount() const;
31256 
31263  MeshKit & SetPriority(int in_priority);
31264 
31267  MeshKit & UnsetPriority();
31268 
31272  bool ShowPriority(int & out_priority) const;
31273 
31277  MeshKit & SetPoints(PointArray const & in_points);
31278 
31283  MeshKit & SetPoints(size_t in_count, Point const in_points []);
31284 
31290  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
31291 
31298  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31299 
31303  MeshKit & SetRows(size_t in_rows);
31304 
31308  MeshKit & SetColumns(size_t in_columns);
31309 
31312  MeshKit & UnsetPoints();
31313 
31316  MeshKit & UnsetRows();
31317 
31320  MeshKit & UnsetColumns();
31321 
31324  MeshKit & UnsetEverything();
31325 
31329  bool ShowPoints(PointArray & out_points) const;
31330 
31336  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31337 
31342  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31343 
31349  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31350 
31356  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31357 
31361  bool ShowRows(size_t & out_rows) const;
31362 
31366  bool ShowColumns(size_t & out_columns) const;
31367 
31368 
31374  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31375 
31382  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31383 
31389  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31390 
31397  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31398 
31405  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31406 
31413  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31414 
31421  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31422 
31428  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31429 
31430 
31437  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31438 
31444  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31445 
31452  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31453 
31460  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31461 
31468  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31469 
31476  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31477 
31483  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31484 
31485 
31492  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31493 
31499  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31500 
31507  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31508 
31515  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31516 
31523  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31524 
31531  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31532 
31538  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31539 
31540 
31546  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31547 
31552  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31553 
31559  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31560 
31566  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31567 
31572  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31573 
31579  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31580 
31585  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31586 
31587 
31594  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31595 
31602  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31603 
31612  MeshKit & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
31613 
31621  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31622 
31623 
31629  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31630 
31635  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31636 
31642  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31643 
31649  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31650 
31655  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31656 
31662  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31663 
31668  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31669 
31670 
31673  MeshKit & UnsetMaterialMapping();
31674 
31677  MeshKit & UnsetVertexColors();
31678 
31683  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31684 
31688  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31689 
31690 
31694  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
31695 
31701  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31702 
31707  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31708 
31709 
31712  MeshKit & UnsetVertexNormals();
31713 
31718  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31719 
31723  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31724 
31725 
31728  MeshKit & UnsetVertexParameters();
31729 
31734  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31735 
31739  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31740 
31741 
31744  MeshKit & UnsetVertexVisibilities();
31745 
31750  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31751 
31755  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31756 
31757 
31760  MeshKit & UnsetVertexEverything();
31761 
31762 
31766  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31767 
31781  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31782  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31783 
31798  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31799  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31800 
31801 
31810  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31811 
31820  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31821 
31822 
31832  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31833 
31843  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31844 
31854  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31855 
31865  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31866 
31867 
31876  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31877 
31886  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31887 
31888 
31894  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31895 
31900  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31901 
31907  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31908 
31914  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31915 
31920  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31921 
31927  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31928 
31933  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31934 
31935 
31941  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31942 
31947  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31948 
31954  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31955 
31961  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31962 
31967  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31968 
31974  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31975 
31980  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31981 
31982 
31988  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31989 
31994  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31995 
32001  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32002 
32008  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32009 
32014  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32015 
32021  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32022 
32027  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32028 
32029 
32035  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32036 
32041  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32042 
32048  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32049 
32055  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32056 
32061  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32062 
32068  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32069 
32074  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32075 
32076 
32079  MeshKit & UnsetFaceColors();
32080 
32085  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32086 
32090  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
32091 
32092 
32095  MeshKit & UnsetFaceNormals();
32096 
32101  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32102 
32106  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32107 
32108 
32111  MeshKit & UnsetFaceVisibilities();
32112 
32117  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32118 
32122  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32123 
32124 
32127  MeshKit & UnsetFaceEverything();
32128 
32129 
32139  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32140 
32151  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32152 
32153 
32162  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32163 
32172  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32173 
32174 
32183  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32184 
32193  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32194 
32200  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32201 
32206  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32207 
32212  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32213 
32217  MeshKit & UnsetUserData(intptr_t in_index);
32218 
32223  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32224 
32228  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
32229 
32232  MeshKit & UnsetAllUserData();
32233 
32235  size_t ShowUserDataCount() const;
32236 
32240  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32241 
32246  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32247 
32252  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32253 
32254 };
32255 
32256 
32257 
32259 class HPS_API MeshKey : public GeometryKey
32260 {
32261 public:
32263  MeshKey();
32264 
32269  explicit MeshKey(Key const & in_that);
32270 
32273  MeshKey(MeshKey const & in_that);
32274 
32278  MeshKey & operator=(MeshKey const & in_that);
32279 
32283  MeshKey(MeshKey && in_that);
32284 
32288  MeshKey & operator=(MeshKey && in_that);
32289 
32290  ~MeshKey();
32291 
32292  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
32293 
32296  void Consume(MeshKit & in_kit);
32297 
32300  void Set(MeshKit const & in_kit);
32301 
32304  void Show(MeshKit & out_kit) const;
32305 
32308  size_t GetPointCount() const;
32309 
32315  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
32316 
32323  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
32324 
32328  bool ShowPoints(PointArray & out_points) const;
32329 
32335  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32336 
32341  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32342 
32348  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32349 
32355  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
32356 
32360  bool ShowRows(size_t & out_rows) const;
32361 
32365  bool ShowColumns(size_t & out_columns) const;
32366 
32367 
32372  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32373 
32376  MeshKey & UnsetMaterialMapping();
32377 
32381  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32382 
32383 
32390  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32391 
32398  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32399 
32406  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32407 
32414  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32415 
32422  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32423 
32430  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32431 
32437  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32438 
32439 
32446  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32447 
32454  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32455 
32462  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32463 
32470  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32471 
32478  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
32479 
32486  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32487 
32493  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
32494 
32495 
32502  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32503 
32510  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32511 
32518  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32519 
32526  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
32527 
32534  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
32535 
32542  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32543 
32549  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
32550 
32551 
32557  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32558 
32564  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32565 
32571  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32572 
32578  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32579 
32584  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32585 
32591  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32592 
32597  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32598 
32599 
32607  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32608 
32615  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32616 
32625  MeshKey & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
32626 
32634  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32635 
32636 
32642  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32643 
32649  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32650 
32656  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32657 
32663  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32664 
32669  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32670 
32676  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32677 
32682  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32683 
32684 
32687  MeshKey & UnsetVertexColors();
32688 
32693  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32694 
32698  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32699 
32700 
32704  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
32705 
32711  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
32712 
32717  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
32718 
32719 
32722  MeshKey & UnsetVertexNormals();
32723 
32728  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
32729 
32733  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
32734 
32735 
32738  MeshKey & UnsetVertexParameters();
32739 
32744  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
32745 
32749  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
32750 
32751 
32754  MeshKey & UnsetVertexVisibilities();
32755 
32760  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
32761 
32765  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
32766 
32767 
32770  MeshKey & UnsetVertexEverything();
32771 
32774  MeshKey & UnsetEverything();
32775 
32776 
32790  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32791  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32792 
32807  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32808  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32809 
32810 
32819  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32820 
32829  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32830 
32831 
32841  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32842 
32852  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32853 
32863  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32864 
32874  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32875 
32876 
32885  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32886 
32895  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32896 
32897 
32903  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32904 
32910  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32911 
32917  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32918 
32924  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32925 
32930  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32931 
32937  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32938 
32943  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32944 
32945 
32951  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32952 
32958  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32959 
32965  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32966 
32972  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32973 
32978  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32979 
32985  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32986 
32991  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32992 
32993 
32999  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33000 
33006  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33007 
33013  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33014 
33020  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33021 
33026  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33027 
33033  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33034 
33039  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33040 
33041 
33047  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33048 
33054  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33055 
33061  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33062 
33068  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33069 
33074  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33075 
33081  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33082 
33087  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33088 
33089 
33092  MeshKey & UnsetFaceColors();
33093 
33098  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33099 
33103  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
33104 
33105 
33108  MeshKey & UnsetFaceNormals();
33109 
33114  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33115 
33119  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
33120 
33121 
33124  MeshKey & UnsetFaceVisibilities();
33125 
33130  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33131 
33135  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
33136 
33137 
33140  MeshKey & UnsetFaceEverything();
33141 
33142 
33152  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33153 
33164  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33165 
33166 
33175  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33176 
33185  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33186 
33187 
33196  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33197 
33206  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33207 
33216  MeshKey & EditMeshByReplacement(size_t in_row_offset, size_t in_column_offset, size_t in_row_count, size_t in_column_count, size_t in_point_count, Point const in_points[]);
33217 
33225  MeshKey & EditMeshByReplacement(size_t in_row_offset, size_t in_column_offset, size_t in_row_count, size_t in_column_count, PointArray const & in_points);
33226 };
33227 
33228 
33229 
33230 
33232 class HPS_API PolygonKit : public Object
33233 {
33234 public:
33236  PolygonKit();
33237 
33240  PolygonKit(PolygonKit const & in_kit);
33241 
33245  PolygonKit(PolygonKit && in_that);
33246 
33250  PolygonKit & operator=(PolygonKit && in_that);
33251 
33252  virtual ~PolygonKit();
33253 
33254  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
33255 
33258  void Consume(PolygonKit & in_kit);
33259 
33262  void Set(PolygonKit const & in_kit);
33263 
33266  void Show(PolygonKit & out_kit) const;
33267 
33271  PolygonKit & operator=(PolygonKit const & in_kit);
33272 
33275  bool Empty() const;
33276 
33280  bool Equals(PolygonKit const & in_kit) const;
33281 
33285  bool operator==(PolygonKit const & in_kit) const;
33286 
33290  bool operator!=(PolygonKit const & in_kit) const;
33291 
33294  size_t GetPointCount() const;
33295 
33302  PolygonKit & SetPriority(int in_priority);
33303 
33306  PolygonKit & UnsetPriority();
33307 
33311  bool ShowPriority(int & out_priority) const;
33312 
33313 
33317  PolygonKit & SetPoints(PointArray const & in_points);
33318 
33323  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
33324 
33327  PolygonKit & UnsetPoints();
33328 
33331  PolygonKit & UnsetEverything();
33332 
33336  bool ShowPoints(PointArray & out_points) const;
33337 
33343  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33344 
33349  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33350 
33356  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33357 
33363  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33364 
33369  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33370 
33375  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33376 
33382  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33383 
33388  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33389 
33395  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33396 
33401  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33402 
33407  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33408 
33412  PolygonKit & UnsetUserData(intptr_t in_index);
33413 
33418  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33419 
33423  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
33424 
33427  PolygonKit & UnsetAllUserData();
33428 
33430  size_t ShowUserDataCount() const;
33431 
33435  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33436 
33441  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33442 
33447  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33448 };
33449 
33450 
33452 class HPS_API PolygonKey : public GeometryKey
33453 {
33454 public:
33456  PolygonKey();
33457 
33462  explicit PolygonKey(Key const & in_that);
33463 
33466  PolygonKey(PolygonKey const & in_that);
33467 
33471  PolygonKey & operator=(PolygonKey const & in_that);
33472 
33476  PolygonKey(PolygonKey && in_that);
33477 
33481  PolygonKey & operator=(PolygonKey && in_that);
33482 
33483  ~PolygonKey();
33484 
33485  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
33486 
33487 
33490  void Consume(PolygonKit & in_kit);
33491 
33494  void Set(PolygonKit const & in_kit);
33495 
33498  void Show(PolygonKit & out_kit) const;
33499 
33502  size_t GetPointCount() const;
33503 
33507  PolygonKey & SetPoints(PointArray const & in_points);
33508 
33513  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
33514 
33518  bool ShowPoints(PointArray & out_points) const;
33519 
33525  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33526 
33531  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33532 
33538  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33539 
33545  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33546 
33551  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33552 
33557  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
33558 
33564  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33565 
33570  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33571 };
33572 
33573 
33574 
33575 
33577 class HPS_API GridKit : public Object
33578 {
33579 public:
33581  GridKit();
33582 
33585  GridKit(GridKit const & in_kit);
33586 
33589  GridKit(GridKit && in_that);
33590 
33591  virtual ~GridKit();
33592 
33593  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
33594 
33597  void Consume(GridKit & in_kit);
33598 
33601  void Set(GridKit const & in_kit);
33602 
33605  void Show(GridKit & out_kit) const;
33606 
33610  GridKit & operator=(GridKit const & in_kit);
33611 
33615  GridKit & operator=(GridKit && in_that);
33616 
33619  bool Empty() const;
33620 
33624  bool Equals(GridKit const & in_kit) const;
33625 
33629  bool operator==(GridKit const & in_kit) const;
33630 
33634  bool operator!=(GridKit const & in_kit) const;
33635 
33636 
33643  GridKit & SetPriority(int in_priority);
33644 
33648  GridKit & SetType(Grid::Type in_type);
33649 
33653  GridKit & SetOrigin(Point const & in_origin);
33654 
33661  GridKit & SetFirstPoint(Point const & in_first_point);
33662 
33670  GridKit & SetSecondPoint(Point const & in_second_point);
33671 
33685  GridKit & SetFirstCount(int in_first_count);
33686 
33697  GridKit & SetSecondCount(int in_second_count);
33698 
33699 
33702  GridKit & UnsetPriority();
33703 
33706  GridKit & UnsetType();
33707 
33710  GridKit & UnsetOrigin();
33711 
33714  GridKit & UnsetFirstPoint();
33715 
33718  GridKit & UnsetSecondPoint();
33719 
33722  GridKit & UnsetFirstCount();
33723 
33726  GridKit & UnsetSecondCount();
33727 
33730  GridKit & UnsetEverything();
33731 
33732 
33736  bool ShowPriority(int & out_priority) const;
33737 
33741  bool ShowType(Grid::Type & out_type) const;
33742 
33746  bool ShowOrigin(Point & out_origin) const;
33747 
33751  bool ShowFirstPoint(Point & out_first_point) const;
33752 
33756  bool ShowSecondPoint(Point & out_second_point) const;
33757 
33761  bool ShowFirstCount(int & out_first_count) const;
33762 
33766  bool ShowSecondCount(int & out_second_count) const;
33767 
33773  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33774 
33779  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33780 
33785  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33786 
33790  GridKit & UnsetUserData(intptr_t in_index);
33791 
33796  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33797 
33801  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
33802 
33805  GridKit & UnsetAllUserData();
33806 
33808  size_t ShowUserDataCount() const;
33809 
33813  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33814 
33819  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33820 
33825  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33826 };
33827 
33828 
33830 class HPS_API GridKey : public GeometryKey
33831 {
33832 public:
33834  GridKey();
33835 
33840  explicit GridKey(Key const & in_that);
33841 
33844  GridKey(GridKey const & in_that);
33845 
33848  GridKey(GridKey && in_that);
33849 
33853  GridKey & operator=(GridKey const & in_that);
33854 
33858  GridKey & operator=(GridKey && in_that);
33859 
33860  ~GridKey();
33861 
33862  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
33863 
33866  void Consume(GridKit & in_kit);
33867 
33870  void Set(GridKit const & in_kit);
33871 
33874  void Show(GridKit & out_kit) const;
33875 
33876 
33880  GridKey & SetType(Grid::Type in_type);
33881 
33885  GridKey & SetOrigin(Point const & in_origin);
33886 
33893  GridKey & SetFirstPoint(Point const & in_first_point);
33894 
33902  GridKey & SetSecondPoint(Point const & in_second_point);
33903 
33917  GridKey & SetFirstCount(int in_first_count);
33918 
33929  GridKey & SetSecondCount(int in_second_count);
33930 
33931 
33932 
33936  bool ShowType(Grid::Type & out_type) const;
33937 
33941  bool ShowOrigin(Point & out_origin) const;
33942 
33946  bool ShowFirstPoint(Point & out_first_point) const;
33947 
33951  bool ShowSecondPoint(Point & out_second_point) const;
33952 
33956  bool ShowFirstCount(int & out_first_count) const;
33957 
33961  bool ShowSecondCount(int & out_second_count) const;
33962 };
33963 
33964 
33965 
33966 
33968 class HPS_API IncludeKey : public Key
33969 {
33970 public:
33972  IncludeKey();
33973 
33978  explicit IncludeKey(Key const & in_that);
33979 
33982  IncludeKey(IncludeKey const & in_that);
33983 
33987  IncludeKey & operator=(IncludeKey const & in_that);
33988 
33992  IncludeKey(IncludeKey && in_that);
33993 
33997  IncludeKey & operator=(IncludeKey && in_that);
33998 
33999  ~IncludeKey();
34000 
34001 
34002  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
34003 
34006  SegmentKey GetTarget() const;
34007 
34008 
34013  IncludeKey & SetPriority(int in_priority);
34014 
34022  IncludeKey & SetCondition(Condition const & in_condition);
34023 
34024 
34027  IncludeKey & UnsetPriority();
34028 
34031  IncludeKey & UnsetCondition();
34032 
34033 
34037  bool ShowPriority(int & out_priority) const;
34038 
34042  bool ShowCondition(Condition & out_condition) const;
34043 
34049  IncludeKey & SetFilter(AttributeLock::Type in_type);
34050 
34057  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34058 
34064  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
34065 
34071  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
34072 
34079  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34080 
34086  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34087 
34093  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34094 
34100  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34101 };
34102 
34103 
34104 
34106 class HPS_API StyleKey : public Key
34107 {
34108 public:
34110  StyleKey();
34111 
34116  explicit StyleKey(Key const & in_that);
34117 
34120  StyleKey(StyleKey const & in_that);
34121 
34125  StyleKey & operator=(StyleKey const & other);
34126 
34130  StyleKey(StyleKey && in_that);
34131 
34135  StyleKey & operator=(StyleKey && in_that);
34136 
34137  ~StyleKey();
34138 
34139  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
34140 
34141 
34147  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
34148 
34149 
34157  StyleKey & SetCondition(Condition const & in_condition);
34158 
34159 
34162  StyleKey & UnsetCondition();
34163 
34164 
34168  bool ShowCondition(Condition & out_condition) const;
34169 
34170 
34176  StyleKey & SetFilter(AttributeLock::Type in_type);
34177 
34184  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34185 
34191  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
34192 
34198  StyleKey & UnsetFilter(AttributeLock::Type in_type);
34199 
34206  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
34207 
34213  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
34214 
34220  bool ShowFilter(AttributeLockTypeArray & out_types) const;
34221 
34227  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
34228 };
34229 
34230 
34231 
34233 class HPS_API ReferenceKey : public GeometryKey
34234 {
34235 public:
34237  ReferenceKey();
34238 
34243  explicit ReferenceKey(Key const & in_that);
34244 
34247  ReferenceKey(ReferenceKey const & in_that);
34248 
34252  ReferenceKey & operator=(ReferenceKey const & in_that);
34253 
34257  ReferenceKey(ReferenceKey && in_that);
34258 
34262  ReferenceKey & operator=(ReferenceKey && in_that);
34263 
34264  ~ReferenceKey();
34265 
34266  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
34267 
34271  Key GetTarget() const;
34272 
34276  size_t ShowTargets(bool masked=true) const;
34277 
34282  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
34283 
34287  size_t ShowGeometryMask() const;
34288 
34293  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
34294 
34298  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
34299 
34302  ReferenceKey & UnsetGeometryMask();
34303 
34306  void SetModellingMatrix(MatrixKit const & in_kit);
34307 
34316  ReferenceKey & SetCondition(Condition const & in_condition);
34317 
34318 
34320  void UnsetModellingMatrix();
34321 
34324  ReferenceKey & UnsetCondition();
34325 
34326 
34330  bool ShowModellingMatrix(MatrixKit & out_kit) const;
34331 
34335  bool ShowCondition(Condition & out_condition) const;
34336 
34337 
34340  ModellingMatrixControl GetModellingMatrixControl();
34341 
34344  ModellingMatrixControl const GetModellingMatrixControl() const;
34345 };
34346 
34347 
34348 
34352 class HPS_API StandAloneWindowOptionsKit : public Object
34353 {
34354 public:
34357 
34361 
34366 
34371 
34372  virtual ~StandAloneWindowOptionsKit();
34373 
34374  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
34375 
34379  static StandAloneWindowOptionsKit GetDefault();
34380 
34383  void Set(StandAloneWindowOptionsKit const & in_kit);
34384 
34387  void Show(StandAloneWindowOptionsKit & out_kit) const;
34388 
34392  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
34393 
34396  bool Empty() const;
34397 
34401  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
34402 
34406  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
34407 
34411  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
34412 
34416  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
34417 
34422  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34423 
34427  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
34428 
34433  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
34434 
34438  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
34439 
34443  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
34444 
34447  StandAloneWindowOptionsKit & UnsetDriver();
34448 
34451  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
34452 
34455  StandAloneWindowOptionsKit & UnsetTitle();
34456 
34459  StandAloneWindowOptionsKit & UnsetSubscreen();
34460 
34463  StandAloneWindowOptionsKit & UnsetMobility();
34464 
34467  StandAloneWindowOptionsKit & UnsetFullScreen();
34468 
34471  StandAloneWindowOptionsKit & UnsetEverything();
34472 
34476  bool ShowDriver(Window::Driver & out_driver) const;
34477 
34482  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34483 
34487  bool ShowTitle(UTF8 & out_window_name) const;
34488 
34492  bool ShowSubscreen(Rectangle & out_subscreen) const;
34493 
34497  bool ShowMobility(Window::Mobility & out_mobility) const;
34498 
34502  bool ShowFullScreen(bool & out_state) const;
34503 };
34504 
34505 
34506 
34513 {
34514 public:
34518 
34522 
34527 
34532 
34535 
34536  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
34537 
34542 
34547  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
34548 
34552  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
34553 
34557  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
34558 
34562  bool ShowDriver(Window::Driver & out_driver) const;
34563 
34568  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34569 
34573  bool ShowTitle(UTF8 & out_window_name) const;
34574 
34578  bool ShowSubscreen(Rectangle & out_subscreen) const;
34579 
34583  bool ShowMobility(Window::Mobility & out_mobility) const;
34584 
34588  bool ShowFullScreen(bool & out_state) const;
34589 
34590 private:
34593 };
34594 
34595 
34596 
34600 class HPS_API OffScreenWindowOptionsKit : public Object
34601 {
34602 public:
34605 
34609 
34614 
34618  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
34619 
34620  virtual ~OffScreenWindowOptionsKit();
34621 
34622  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
34623 
34627  static OffScreenWindowOptionsKit GetDefault();
34628 
34631  void Set(OffScreenWindowOptionsKit const & in_kit);
34632 
34635  void Show(OffScreenWindowOptionsKit & out_kit) const;
34636 
34640  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
34641 
34644  bool Empty() const;
34645 
34649  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
34650 
34654  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
34655 
34659  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
34660 
34664  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
34665 
34670  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34671 
34676  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
34677 
34682  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
34683 
34688  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
34689 
34693  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
34694 
34697  OffScreenWindowOptionsKit & UnsetDriver();
34698 
34701  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
34702 
34705  OffScreenWindowOptionsKit & UnsetHardwareResident();
34706 
34709  OffScreenWindowOptionsKit & UnsetNativeFormat();
34710 
34713  OffScreenWindowOptionsKit & UnsetOpacity();
34714 
34717  OffScreenWindowOptionsKit & UnsetEverything();
34718 
34722  bool ShowDriver(Window::Driver & out_driver) const;
34723 
34728  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34729 
34733  bool ShowHardwareResident(bool & out_state) const;
34734 
34739  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
34740 
34745  bool ShowOpacity(bool & out_state, float & out_opacity) const;
34746 };
34747 
34751 class HPS_API ApplicationWindowOptionsKit : public Object
34752 {
34753 public:
34756 
34760 
34765 
34770 
34771  virtual ~ApplicationWindowOptionsKit();
34772 
34773  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
34774 
34778  static ApplicationWindowOptionsKit GetDefault();
34779 
34782  void Set(ApplicationWindowOptionsKit const & in_kit);
34783 
34786  void Show(ApplicationWindowOptionsKit & out_kit) const;
34787 
34791  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
34792 
34795  bool Empty() const;
34796 
34800  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
34801 
34805  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
34806 
34810  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
34811 
34815  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
34816 
34821  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
34822 
34826  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
34827 
34831  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
34832 
34835  ApplicationWindowOptionsKit & UnsetDriver();
34836 
34839  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
34840 
34843  ApplicationWindowOptionsKit & UnsetPlatformData();
34844 
34847  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
34848 
34851  ApplicationWindowOptionsKit & UnsetEverything();
34852 
34856  bool ShowDriver(Window::Driver & out_driver) const;
34857 
34862  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34863 
34867  bool ShowPlatformData(PlatformData & out_platform_data) const;
34868 
34872  bool ShowFramebufferRetention(bool & out_retain) const;
34873 
34874 };
34875 
34876 
34877 
34880 {
34881 public:
34885 
34889 
34894 
34899 
34902 
34903  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
34904 
34909 
34914  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34915 
34919  bool ShowDriver(Window::Driver & out_driver) const;
34920 
34924  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
34925 
34929  bool ShowPlatformData(PlatformData & out_platform_data) const;
34930 
34934  bool ShowFramebufferRetention(bool & out_retain) const;
34935 
34939  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
34940 
34944  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
34945 
34946 private:
34949 };
34950 
34951 
34952 
34957 class HPS_API StandAloneWindowKey : public WindowKey
34958 {
34959 public:
34962 
34967  StandAloneWindowKey(Key const & in_key);
34968 
34971  StandAloneWindowKey(StandAloneWindowKey const & in_that);
34972 
34977 
34981  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
34982 
34984 
34985  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
34986 
34989  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
34990 
34993  StandAloneWindowOptionsControl GetWindowOptionsControl();
34994 
34998  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
34999 
35002  Window::UpdateStatus Pause();
35003 };
35004 
35005 
35006 
35008 class HPS_API ApplicationWindowKey : public WindowKey
35009 {
35010 public:
35013 
35018  ApplicationWindowKey(Key const & in_key);
35019 
35022  ApplicationWindowKey(ApplicationWindowKey const & in_that);
35023 
35028 
35032  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
35033 
35035 
35036  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
35037 
35040  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
35041 
35044  ApplicationWindowOptionsControl GetWindowOptionsControl();
35045 
35049  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
35050 };
35051 
35055 
35056 
35057 
35059 class HPS_API GlyphElement : public Object
35060 {
35061 public:
35063  GlyphElement();
35064 
35067  GlyphElement(GlyphElement const & in_that);
35068 
35072  GlyphElement(GlyphElement && in_that);
35073 
35077  GlyphElement & operator=(GlyphElement && in_that);
35078 
35079  virtual ~GlyphElement();
35080 
35081  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
35082 
35085  void Set(GlyphElement const & in_that);
35086 
35090  GlyphElement & operator=(GlyphElement const & in_that);
35091 
35095  bool Equals(GlyphElement const & in_that) const;
35096 
35100  bool operator==(GlyphElement const & in_that) const;
35101 
35105  bool operator!=(GlyphElement const & in_that) const;
35106 
35109  void SetFill(Glyph::Fill in_fill);
35110 
35113  void SetIndexedColor(byte in_index);
35114 
35116  void SetNormalColor();
35117 
35120  void SetExplicitColor(RGBAColor const & in_color);
35121 
35125  bool ShowFill(Glyph::Fill & out_fill) const;
35126 
35132  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
35133 };
35134 
35135 
35137 class HPS_API LineGlyphElement : public GlyphElement
35138 {
35139 public:
35141  LineGlyphElement();
35142 
35147  LineGlyphElement(GlyphElement const & in_that);
35148 
35151  LineGlyphElement(LineGlyphElement const & in_that);
35152 
35155  explicit LineGlyphElement(GlyphPointArray const & in_points);
35156 
35160  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
35161 
35165  LineGlyphElement(LineGlyphElement && in_that);
35166 
35170  LineGlyphElement & operator=(LineGlyphElement && in_that);
35171 
35172  ~LineGlyphElement();
35173 
35174  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
35175 
35178  void SetPoints(GlyphPointArray const & in_points);
35179 
35183  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
35184 
35188  bool ShowPoints(GlyphPointArray & out_points) const;
35189 };
35190 
35192 class HPS_API DotGlyphElement : public GlyphElement
35193 {
35194 public:
35196  DotGlyphElement();
35197 
35202  DotGlyphElement(GlyphElement const & in_that);
35203 
35206  DotGlyphElement(DotGlyphElement const & in_that);
35207 
35210  explicit DotGlyphElement(GlyphPoint const & in_point);
35211 
35215  DotGlyphElement(DotGlyphElement && in_that);
35216 
35220  DotGlyphElement & operator=(DotGlyphElement && in_that);
35221 
35222  ~DotGlyphElement();
35223 
35224  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
35225 
35228  void SetPoint(GlyphPoint const & in_point);
35229 
35233  bool ShowPoint(GlyphPoint & out_point) const;
35234 };
35235 
35236 
35238 class HPS_API EllipseGlyphElement : public GlyphElement
35239 {
35240 public:
35243 
35248  EllipseGlyphElement(GlyphElement const & in_that);
35249 
35252  EllipseGlyphElement(EllipseGlyphElement const & in_that);
35253 
35257  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35258 
35263 
35267  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
35268 
35270 
35271  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
35272 
35275  void SetLowerLeft(GlyphPoint const & in_point);
35276 
35279  void SetUpperRight(GlyphPoint const & in_point);
35280 
35284  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
35285 
35289  bool ShowLowerLeft(GlyphPoint & out_point) const;
35290 
35294  bool ShowUpperRight(GlyphPoint & out_point) const;
35295 };
35296 
35297 
35300 {
35301 public:
35304 
35309  CircularArcGlyphElement(GlyphElement const & in_that);
35310 
35314 
35319  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35320 
35325 
35329  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
35330 
35332 
35333  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
35334 
35337  void SetStartPoint(GlyphPoint const & in_point);
35338 
35341  void SetIntermediatePoint(GlyphPoint const & in_point);
35342 
35345  void SetEndPoint(GlyphPoint const & in_point);
35346 
35351  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
35352 
35356  bool ShowStartPoint(GlyphPoint & out_point) const;
35357 
35361  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
35362 
35366  bool ShowEndPoint(GlyphPoint & out_point) const;
35367 };
35368 
35369 
35370 
35373 {
35374 public:
35377 
35382  InfiniteLineGlyphElement(GlyphElement const & in_that);
35383 
35387 
35391  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
35392 
35397 
35401  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
35402 
35404 
35405  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
35406 
35409  void SetFirstPoint(GlyphPoint const & in_point);
35410 
35413  void SetSecondPoint(GlyphPoint const & in_point);
35414 
35418  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
35419 
35422  void SetInfiniteType(InfiniteLine::Type in_type);
35423 
35427  bool ShowFirstPoint(GlyphPoint & out_point) const;
35428 
35432  bool ShowSecondPoint(GlyphPoint & out_point) const;
35433 
35437  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
35438 };
35439 
35440 
35441 
35443 class HPS_API GlyphKit : public Object
35444 {
35445 public:
35447  GlyphKit();
35448 
35451  GlyphKit(GlyphKit const & in_kit);
35452 
35456  GlyphKit(GlyphKit && in_that);
35457 
35461  GlyphKit & operator=(GlyphKit && in_that);
35462 
35463  virtual ~GlyphKit();
35464 
35465  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
35466 
35470  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
35471 
35474  void Set(GlyphKit const & in_kit);
35475 
35478  void Show(GlyphKit & out_kit) const;
35479 
35483  GlyphKit & operator=(GlyphKit const & in_kit);
35484 
35487  bool Empty() const;
35488 
35492  bool Equals(GlyphKit const & in_kit) const;
35493 
35497  bool operator==(GlyphKit const & in_kit) const;
35498 
35502  bool operator!=(GlyphKit const & in_kit) const;
35503 
35507  GlyphKit & SetRadius(sbyte in_radius);
35508 
35513  GlyphKit & SetOffset(GlyphPoint const & in_point);
35514 
35518  GlyphKit & SetElements(GlyphElementArray const & in_def);
35519 
35524  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
35525 
35528  GlyphKit & UnsetRadius();
35529 
35532  GlyphKit & UnsetOffset();
35533 
35536  GlyphKit & UnsetElements();
35537 
35540  GlyphKit & UnsetEverything();
35541 
35545  bool ShowRadius(sbyte & out_radius) const;
35546 
35550  bool ShowOffset(GlyphPoint & out_point) const;
35551 
35555  bool ShowElements(GlyphElementArray & out_def) const;
35556 };
35557 
35561 
35562 
35565 class HPS_API LinePatternOptionsKit : public Object
35566 {
35567 public:
35570 
35574 
35579 
35583  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
35584 
35585  virtual ~LinePatternOptionsKit();
35586 
35587  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
35588 
35591  void Set(LinePatternOptionsKit const & in_kit);
35592 
35595  void Show(LinePatternOptionsKit & out_kit) const;
35596 
35600  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
35601 
35604  bool Empty() const;
35605 
35609  bool Equals(LinePatternOptionsKit const & in_kit) const;
35610 
35614  bool operator==(LinePatternOptionsKit const & in_kit) const;
35615 
35619  bool operator!=(LinePatternOptionsKit const & in_kit) const;
35620 
35624  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
35625 
35629  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
35630 
35634  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
35635 
35639  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
35640 
35644  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
35645 
35649  LinePatternOptionsKit & SetJoin(char const * in_glyph);
35650 
35654  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
35655 
35659  LinePatternOptionsKit & UnsetStartCap();
35660 
35664  LinePatternOptionsKit & UnsetEndCap();
35665 
35668  LinePatternOptionsKit & UnsetInnerCap();
35669 
35673  LinePatternOptionsKit & UnsetJoin();
35674 
35677  LinePatternOptionsKit & UnsetEverything();
35678 
35684  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35685 
35691  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
35692 
35696  bool ShowInnerCap(LinePattern::Cap & out_type) const;
35697 
35703  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
35704 };
35705 
35708 class HPS_API LinePatternElement : public Object
35709 {
35710 public:
35713 
35716  LinePatternElement(LinePatternElement const & in_that);
35717 
35722 
35726  LinePatternElement & operator=(LinePatternElement && in_that);
35727 
35728  ~LinePatternElement();
35729 
35730  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
35731 
35734  void Set(LinePatternElement const & in_that);
35735 
35739  LinePatternElement & operator=(LinePatternElement const & in_that);
35740 
35744  bool Equals(LinePatternElement const & in_that) const;
35745 
35749  bool operator==(LinePatternElement const & in_that) const;
35750 
35754  bool operator!=(LinePatternElement const & in_that) const;
35755 
35759  void SetSize(float in_size, LinePattern::SizeUnits in_units);
35760 
35765  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
35766 };
35767 
35770 {
35771 public:
35774 
35780 
35784 
35788  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35789 
35794 
35798  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
35799 
35801 
35802  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
35803 
35807  void SetColor(RGBAColor const & in_color);
35808 
35812  void SetMaterialByIndex(float in_material_index);
35813 
35819  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
35820 };
35821 
35822 
35825 {
35826 public:
35829 
35835 
35839 
35843  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
35844 
35849 
35853  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
35854 
35856 
35857  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
35858 };
35859 
35860 
35863 {
35864 public:
35867 
35873 
35877 
35881  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
35882 
35887 
35891  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
35892 
35894 
35895  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
35896 
35899  void SetSource(char const * in_source);
35900 
35904  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
35905 
35908  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
35909 
35912  void SetMirror(bool in_state);
35913 
35916  void SetFixed(bool in_state);
35917 
35920  void SetRotation(float in_degrees);
35921 
35925  bool ShowSource(UTF8 & out_source) const;
35926 
35931  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
35932 
35936  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
35937 
35941  bool ShowMirror(bool & out_state) const;
35942 
35946  bool ShowFixed(bool & out_state) const;
35947 
35951  bool ShowRotation(float & out_degrees) const;
35952 };
35953 
35955 class HPS_API LinePatternParallelKit : public Object
35956 {
35957 public:
35960 
35964 
35969 
35973  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
35974 
35975  virtual ~LinePatternParallelKit();
35976 
35977  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
35978 
35981  void Set(LinePatternParallelKit const & in_kit);
35982 
35985  void Show(LinePatternParallelKit & out_kit) const;
35986 
35990  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
35991 
35994  bool Empty() const;
35995 
35999  bool Equals(LinePatternParallelKit const & in_kit) const;
36000 
36004  bool operator==(LinePatternParallelKit const & in_kit) const;
36005 
36009  bool operator!=(LinePatternParallelKit const & in_kit) const;
36010 
36014  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
36015 
36019  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
36020 
36024  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
36025 
36029  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
36030 
36035  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
36036 
36040  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
36041 
36045  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
36046 
36050  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
36051 
36058  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
36059 
36065  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
36066 
36070  LinePatternParallelKit & SetContinuous(bool in_state);
36071 
36074  LinePatternParallelKit & UnsetStartCap();
36075 
36078  LinePatternParallelKit & UnsetEndCap();
36079 
36082  LinePatternParallelKit & UnsetJoin();
36083 
36086  LinePatternParallelKit & UnsetBody();
36087 
36090  LinePatternParallelKit & UnsetAbsoluteLength();
36091 
36094  LinePatternParallelKit & UnsetAbsoluteWeight();
36095 
36098  LinePatternParallelKit & UnsetJustification();
36099 
36102  LinePatternParallelKit & UnsetOffset();
36103 
36106  LinePatternParallelKit & UnsetWeight();
36107 
36110  LinePatternParallelKit & UnsetContinuous();
36111 
36114  LinePatternParallelKit & UnsetEverything();
36115 
36119  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
36120 
36124  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
36125 
36129  bool ShowJoin(GlyphLinePatternElement & out_join) const;
36130 
36134  bool ShowBody(LinePatternElementArray & out_elements) const;
36135 
36139  bool ShowAbsoluteLength(bool & out_state) const;
36140 
36144  bool ShowAbsoluteWeight(bool & out_state) const;
36145 
36149  bool ShowJustification(LinePattern::Justification & out_type) const;
36150 
36156  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36157 
36163  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
36164 
36168  bool ShowContinuous(bool & out_state) const;
36169 };
36170 
36171 
36173 class HPS_API LinePatternKit : public Object
36174 {
36175 public:
36177  LinePatternKit();
36178 
36181  LinePatternKit(LinePatternKit const & in_kit);
36182 
36186  LinePatternKit(LinePatternKit && in_that);
36187 
36191  LinePatternKit & operator=(LinePatternKit && in_that);
36192 
36193  virtual ~LinePatternKit();
36194 
36195  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
36196 
36200  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
36201 
36204  void Set(LinePatternKit const & in_kit);
36205 
36208  void Show(LinePatternKit & out_kit) const;
36209 
36213  LinePatternKit & operator=(LinePatternKit const & in_kit);
36214 
36217  bool Empty() const;
36218 
36222  bool Equals(LinePatternKit const & in_kit) const;
36223 
36227  bool operator==(LinePatternKit const & in_kit) const;
36228 
36232  bool operator!=(LinePatternKit const & in_kit) const;
36233 
36237  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
36238 
36243  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
36244 
36248  LinePatternKit & SetJoin(LinePattern::Join in_type);
36249 
36252  LinePatternKit & UnsetParallels();
36253 
36256  LinePatternKit & UnsetJoin();
36257 
36260  LinePatternKit & UnsetEverything();
36261 
36265  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
36266 
36270  bool ShowJoin(LinePattern::Join & out_type) const;
36271 };
36272 
36273 
36274 
36278 
36279 
36281 class HPS_API Definition : public Object
36282 {
36283 public:
36285  Definition();
36286 
36289  Definition(Definition const & in_that);
36290 
36294  Definition & operator=(Definition const & in_that);
36295 
36299  Definition(Definition && in_that);
36300 
36304  Definition & operator=(Definition && in_that);
36305 
36306  virtual ~Definition();
36307 
36308  HPS::Type ObjectType() const { return HPS::Type::Definition; };
36309 
36311  void Undefine();
36312 
36315  PortfolioKey Owner() const;
36316 
36319  UTF8 Name() const;
36320 
36323  virtual void Assign(Definition const & in_that);
36324 
36328  bool Equals(Definition const & in_that) const;
36329 
36333  bool operator==(Definition const & in_that) const;
36334 
36338  bool operator!=(Definition const & in_that) const;
36339 };
36340 
36341 
36344 class HPS_API PortfolioKey : public Key
36345 {
36346 public:
36348  PortfolioKey();
36349 
36354  explicit PortfolioKey(Key const & in_that);
36355 
36358  PortfolioKey(PortfolioKey const & in_that);
36359 
36363  PortfolioKey & operator=(PortfolioKey const & in_that);
36364 
36368  PortfolioKey(PortfolioKey && in_that);
36369 
36373  PortfolioKey & operator=(PortfolioKey && in_that);
36374 
36375  ~PortfolioKey();
36376 
36377  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
36378 
36379  // Define
36380 
36387  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
36388 
36396  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
36397 
36398 
36410  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36411  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36412  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36413 
36426  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36427  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36428  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
36429 
36430 
36436  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
36437 
36438 
36444  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
36445 
36446 
36452  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
36453 
36460  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
36461 
36462 
36468  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
36469 
36470 
36476  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
36477 
36478 
36484  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
36485 
36486 
36487  // UnDefine
36488 
36492  PortfolioKey & UndefineTexture(char const * in_name);
36493 
36497  PortfolioKey & UndefineCubeMap(char const * in_name);
36498 
36502  PortfolioKey & UndefineImage(char const * in_name);
36503 
36507  PortfolioKey & UndefineNamedStyle(char const * in_name);
36508 
36512  PortfolioKey & UndefineMaterialPalette(char const * in_name);
36513 
36517  PortfolioKey & UndefineGlyph(char const * in_name);
36518 
36522  PortfolioKey & UndefineLinePattern(char const * in_name);
36523 
36527  PortfolioKey & UndefineShader(char const * in_name);
36528 
36529 
36530  // Import collections
36536  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36537 
36538 
36544  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36545 
36551  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36552 
36558  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36559 
36565  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36566 
36572  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36573 
36579  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36580 
36586  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36587 
36593  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
36594 
36595 
36596  // Import individual definitions
36600  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
36601 
36605  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
36606 
36610  ImageDefinition ImportImage(ImageDefinition const & in_definition);
36611 
36615  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
36616 
36620  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
36621 
36625  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
36626 
36630  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
36631 
36635  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
36636 
36637 
36638  // Show
36640  size_t GetDefinitionCount() const;
36641 
36643  size_t GetTextureDefinitionCount() const;
36644 
36646  size_t GetCubeMapDefinitionCount() const;
36647 
36649  size_t GetImageDefinitionCount() const;
36650 
36652  size_t GetNamedStyleDefinitionCount() const;
36653 
36655  size_t GetMaterialPaletteDefinitionCount() const;
36656 
36658  size_t GetGlyphDefinitionCount() const;
36659 
36661  size_t GetLinePatternDefinitionCount() const;
36662 
36664  size_t GetShaderDefinitionCount() const;
36665 
36670  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
36671 
36675  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
36676 
36681  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
36682 
36686  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
36687 
36692  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
36693 
36697  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
36698 
36703  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
36704 
36708  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
36709 
36714  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
36715 
36719  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
36720 
36725  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
36726 
36730  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
36731 
36736  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
36737 
36741  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
36742 
36747  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
36748 
36752  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
36753 
36754 private:
36756  void MoveTo(SegmentKey const & in_new_owner);
36757 
36759  Key CopyTo(SegmentKey const & in_destination) const;
36760 };
36761 
36762 
36763 
36765 class HPS_API GlyphDefinition : public Definition
36766 {
36767 public:
36769  GlyphDefinition();
36770 
36775  GlyphDefinition(Definition const & in_that);
36776 
36779  GlyphDefinition(GlyphDefinition const & in_that);
36780 
36784  GlyphDefinition & operator=(GlyphDefinition const & in_that);
36785 
36789  GlyphDefinition(GlyphDefinition && in_that);
36790 
36794  GlyphDefinition & operator=(GlyphDefinition && in_that);
36795 
36796  ~GlyphDefinition();
36797 
36798  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
36799 
36802  void Set(GlyphKit const & in_kit);
36803 
36806  void Show(GlyphKit & out_kit) const;
36807 };
36808 
36809 
36811 class HPS_API TextureDefinition : public Definition
36812 {
36813 public:
36816 
36821  TextureDefinition(Definition const & in_that);
36822 
36825  TextureDefinition(TextureDefinition const & in_that);
36826 
36830  TextureDefinition & operator=(TextureDefinition const & in_that);
36831 
36836 
36840  TextureDefinition & operator=(TextureDefinition && in_that);
36841 
36842  ~TextureDefinition();
36843 
36844  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
36845 
36848  void SetSource(ImageDefinition const & in_source);
36849 
36852  void ShowSource(ImageDefinition & out_source) const;
36853 
36856  void SetOptions(TextureOptionsKit const & in_options);
36857 
36860  void ShowOptions(TextureOptionsKit & out_options) const;
36861 
36862 };
36863 
36867 class HPS_API TextureOptionsKit : public Object
36868 {
36869 public:
36872 
36875  TextureOptionsKit(TextureOptionsKit const & in_kit);
36876 
36881 
36885  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
36886 
36887  virtual ~TextureOptionsKit();
36888 
36889  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
36890 
36894  static TextureOptionsKit GetDefault();
36895 
36898  void Set(TextureOptionsKit const & in_kit);
36899 
36902  void Show(TextureOptionsKit & out_kit) const;
36903 
36907  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
36908 
36911  bool Empty() const;
36912 
36916  bool Equals(TextureOptionsKit const & in_kit) const;
36917 
36921  bool operator==(TextureOptionsKit const & in_kit) const;
36922 
36926  bool operator!=(TextureOptionsKit const & in_kit) const;
36927 
36932  TextureOptionsKit & SetDecal(bool in_state);
36933 
36937  TextureOptionsKit & SetDownSampling(bool in_state);
36938 
36942  TextureOptionsKit & SetModulation(bool in_state);
36943 
36947  TextureOptionsKit & SetParameterOffset(size_t in_offset);
36948 
36952  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
36953 
36957  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
36958 
36962  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
36963 
36967  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
36968 
36972  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
36973 
36976  TextureOptionsKit & UnsetDecal();
36977 
36980  TextureOptionsKit & UnsetDownSampling();
36981 
36984  TextureOptionsKit & UnsetModulation();
36985 
36988  TextureOptionsKit & UnsetParameterOffset();
36989 
36992  TextureOptionsKit & UnsetParameterizationSource();
36993 
36996  TextureOptionsKit & UnsetTiling();
36997 
37000  TextureOptionsKit & UnsetInterpolationFilter();
37001 
37004  TextureOptionsKit & UnsetDecimationFilter();
37005 
37008  TextureOptionsKit & UnsetTransformMatrix();
37009 
37012  TextureOptionsKit & UnsetEverything();
37013 
37017  bool ShowDecal(bool & out_state) const;
37018 
37022  bool ShowDownSampling(bool & out_state) const;
37023 
37027  bool ShowModulation(bool & out_state) const;
37028 
37032  bool ShowParameterOffset(size_t & out_offset) const;
37033 
37037  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
37038 
37042  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
37043 
37047  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
37048 
37052  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
37053 
37057  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37058 };
37059 
37060 
37062 class HPS_API Image
37063 {
37064 public:
37067  enum class Format
37068  {
37069  RGB,
37070  RGBA,
37071  ARGB,
37072  Mapped8,
37073  Grayscale,
37074  Bmp,
37075  Jpeg,
37076  Png,
37077  Targa,
37078  DXT1,
37079  DXT3,
37080  DXT5
37081  };
37082 
37084  class HPS_API ExportOptionsKit : public Object
37085  {
37086  public:
37088  ExportOptionsKit();
37089 
37092  ExportOptionsKit(ExportOptionsKit const & in_kit);
37093 
37097  ExportOptionsKit(ExportOptionsKit && in_that);
37098 
37102  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
37103 
37104  virtual ~ExportOptionsKit();
37105 
37106  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
37107 
37111  static ExportOptionsKit GetDefault();
37112 
37115  void Set(ExportOptionsKit const & in_kit);
37116 
37119  void Show(ExportOptionsKit & out_kit) const;
37120 
37124  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
37125 
37128  bool Empty() const;
37129 
37133  bool Equals(ExportOptionsKit const & in_kit) const;
37134 
37138  bool operator==(ExportOptionsKit const & in_kit) const;
37139 
37143  bool operator!=(ExportOptionsKit const & in_kit) const;
37144 
37149  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37150 
37155  ExportOptionsKit & SetFormat(Image::Format in_format);
37156 
37159  ExportOptionsKit & UnsetSize();
37160 
37163  ExportOptionsKit & UnsetFormat();
37164 
37167  ExportOptionsKit & UnsetEverything();
37168 
37173  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37174 
37178  bool ShowFormat(Image::Format & out_format) const;
37179  };
37180 
37182  class HPS_API ImportOptionsKit : public Object
37183  {
37184  public:
37186  ImportOptionsKit();
37187 
37190  ImportOptionsKit(ImportOptionsKit const & in_kit);
37191 
37195  ImportOptionsKit(ImportOptionsKit && in_that);
37196 
37200  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37201 
37202  virtual ~ImportOptionsKit();
37203 
37204  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
37205 
37208  void Set(ImportOptionsKit const & in_kit);
37209 
37212  void Show(ImportOptionsKit & out_kit) const;
37213 
37217  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37218 
37221  bool Empty() const;
37222 
37226  bool Equals(ImportOptionsKit const & in_kit) const;
37227 
37231  bool operator==(ImportOptionsKit const & in_kit) const;
37232 
37236  bool operator!=(ImportOptionsKit const & in_kit) const;
37237 
37244  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
37245 
37249  ImportOptionsKit & SetFormat(Image::Format in_format);
37250 
37255  ImportOptionsKit & SetDownSampling(bool in_state);
37256 
37261  ImportOptionsKit & SetCompressionQuality(float in_quality);
37262 
37265  ImportOptionsKit & UnsetSize();
37266 
37269  ImportOptionsKit & UnsetFormat();
37270 
37273  ImportOptionsKit & UnsetDownSampling();
37274 
37277  ImportOptionsKit & UnsetCompressionQuality();
37278 
37281  ImportOptionsKit & UnsetEverything();
37282 
37287  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37288 
37292  bool ShowFormat(Image::Format & out_format) const;
37293 
37297  bool ShowDownSampling(bool & out_state) const;
37298 
37302  bool ShowCompressionQuality(float & out_quality) const;
37303  };
37304 
37306  class HPS_API File
37307  {
37308  public:
37314  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37315 
37322  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
37323 
37331  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, unsigned int in_width, unsigned int in_height, Format in_format = Format::Png);
37332 
37337  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
37338 
37339  private:
37341  File();
37342  };
37343 
37344 private:
37346  Image();
37347 };
37348 
37349 
37351 class HPS_API ImageKit : public Object
37352 {
37353 public:
37355  ImageKit();
37356 
37359  ImageKit(ImageKit const & in_kit);
37360 
37365  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
37366 
37370  ImageKit(ImageKit && in_that);
37371 
37375  ImageKit & operator=(ImageKit && in_that);
37376 
37377  virtual ~ImageKit();
37378 
37379  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
37380 
37383  void Set(ImageKit const & in_kit);
37384 
37387  void Show(ImageKit & out_kit) const;
37388 
37392  ImageKit & operator=(ImageKit const & in_kit);
37393 
37396  bool Empty() const;
37397 
37401  bool Equals(ImageKit const & in_kit) const;
37402 
37406  bool operator==(ImageKit const & in_kit) const;
37407 
37411  bool operator!=(ImageKit const & in_kit) const;
37412 
37416  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
37417 
37420  void Convert(HPS::Image::Format in_format);
37421 
37426  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
37427 
37431  ImageKit & SetData(ByteArray const & in_image_data);
37432 
37437  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
37438 
37442  ImageKit & SetFormat(Image::Format in_format);
37443 
37447  ImageKit & SetDownSampling(bool in_state);
37448 
37452  ImageKit & SetCompressionQuality(float in_quality);
37453 
37456  ImageKit & UnsetSize();
37457 
37460  ImageKit & UnsetData();
37461 
37464  ImageKit & UnsetFormat();
37465 
37468  ImageKit & UnsetDownSampling();
37469 
37472  ImageKit & UnsetCompressionQuality();
37473 
37476  ImageKit & UnsetEverything();
37477 
37482  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37483 
37487  bool ShowData(ByteArray & out_image_data) const;
37488 
37492  bool ShowFormat(Image::Format & out_format) const;
37493 
37497  bool ShowDownSampling(bool & out_state) const;
37498 
37502  bool ShowCompressionQuality(float & out_quality) const;
37503 };
37504 
37505 
37511 {
37512 public:
37516 
37521 
37526 
37531 
37533 
37534  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
37535 
37539  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
37540 
37545  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
37546 
37551  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
37552 
37556  bool ShowDriver(Window::Driver & out_driver) const;
37557 
37562  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37563 
37568  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
37569 
37574  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
37575 
37580  bool ShowImage(ByteArray & out_bytes) const;
37581 
37585  bool ShowHardwareResident(bool & out_state) const;
37586 
37591  bool ShowOpacity(bool & out_state, float & out_opacity) const;
37592 
37597  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
37598 
37599 
37600 private:
37603 };
37604 
37605 
37608 class HPS_API OffScreenWindowKey : public WindowKey
37609 {
37610 public:
37613 
37618  OffScreenWindowKey(Key const & in_key);
37619 
37622  OffScreenWindowKey(OffScreenWindowKey const & in_that);
37623 
37628 
37632  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
37633 
37634  ~OffScreenWindowKey();
37635 
37636  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
37637 
37640  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
37641 
37644  OffScreenWindowOptionsControl GetWindowOptionsControl();
37645 
37649  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
37650 };
37651 
37652 
37653 
37654 
37656 class HPS_API ImageDefinition : public Definition
37657 {
37658 public:
37660  ImageDefinition();
37661 
37666  ImageDefinition(Definition const & in_that);
37667 
37670  ImageDefinition(ImageDefinition const & in_that);
37671 
37675  ImageDefinition & operator=(ImageDefinition const & in_that);
37676 
37680  ImageDefinition(ImageDefinition && in_that);
37681 
37685  ImageDefinition & operator=(ImageDefinition && in_that);
37686 
37687  ~ImageDefinition();
37688 
37689  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
37690 
37693  void Set(ImageKit const & in_kit);
37694 
37697  void Show(ImageKit & out_kit) const;
37698 };
37699 
37701 class HPS_API CubeMapDefinition : public Definition
37702 {
37703 public:
37706 
37711  CubeMapDefinition(Definition const & in_that);
37712 
37715  CubeMapDefinition(CubeMapDefinition const & in_that);
37716 
37720  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
37721 
37726 
37730  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
37731 
37732  ~CubeMapDefinition();
37733 
37734  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
37735 
37743  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
37744  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
37745  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
37746 
37754  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
37755  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
37756  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
37757 
37761  void ShowSource(ImageDefinitionArray & out_image_sources) const;
37762 
37765  void SetOptions(TextureOptionsKit const & in_options);
37766 
37769  void ShowOptions(TextureOptionsKit & out_options) const;
37770 };
37771 
37772 
37774 class HPS_API NamedStyleDefinition : public Definition
37775 {
37776 public:
37779 
37784  NamedStyleDefinition(Definition const & in_that);
37785 
37788  NamedStyleDefinition(NamedStyleDefinition const & in_that);
37789 
37793  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
37794 
37799 
37803  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
37804 
37806 
37807  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
37808 
37812  SegmentKey GetSource() const;
37813 };
37814 
37815 
37818 {
37819 public:
37822 
37827  MaterialPaletteDefinition(Definition const & in_that);
37828 
37832 
37836  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
37837 
37842 
37846  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
37847 
37849 
37850  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
37851 
37854  void Set(MaterialKitArray const & in_source);
37855 
37859  void Set(size_t in_count, MaterialKit const in_source []);
37860 
37863  void Show(MaterialKitArray & out_source) const;
37864 };
37865 
37866 
37867 
37869 class HPS_API LinePatternDefinition : public Definition
37870 {
37871 public:
37874 
37879  LinePatternDefinition(Definition const & in_that);
37880 
37884 
37888  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
37889 
37894 
37898  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
37899 
37901 
37902  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
37903 
37906  void Set(LinePatternKit const & in_kit);
37907 
37910  void Show(LinePatternKit & out_kit) const;
37911 };
37912 
37913 
37914 
37916 class HPS_API Shader
37917 {
37918 public:
37921  enum class Parameterization
37922  {
37924  Cylinder,
37926  PhysicalReflection,
37928  Object,
37934  NaturalUV,
37936  ReflectionVector,
37938  SurfaceNormal,
37940  Sphere,
37942  UV,
37944  World
37945  };
37946 
37948  class HPS_API ImportOptionsKit : public Object
37949  {
37950  public:
37952  ImportOptionsKit();
37953 
37956  ImportOptionsKit(ImportOptionsKit const & in_kit);
37957 
37961  ImportOptionsKit(ImportOptionsKit && in_that);
37962 
37966  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37967 
37968  virtual ~ImportOptionsKit();
37969 
37970  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
37971 
37974  void Set(ImportOptionsKit const & in_kit);
37975 
37978  void Show(ImportOptionsKit & out_kit) const;
37979 
37983  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37984 
37987  bool Empty() const;
37988 
37992  bool Equals(ImportOptionsKit const & in_kit) const;
37993 
37997  bool operator==(ImportOptionsKit const & in_kit) const;
37998 
38002  bool operator!=(ImportOptionsKit const & in_kit) const;
38003 
38010  ImportOptionsKit & SetMultitexture(bool in_state);
38011 
38015  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38016 
38020  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
38021 
38025  ImportOptionsKit & UnsetMultitexture();
38026 
38029  ImportOptionsKit & UnsetParameterizationSource();
38030 
38033  ImportOptionsKit & UnsetTransformMatrix();
38034 
38037  ImportOptionsKit & UnsetEverything();
38038 
38044  bool ShowMultitexture(bool & out_state) const;
38045 
38049  bool ShowParameterizationSource(Parameterization & out_source) const;
38050 
38054  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38055  };
38056 
38058  class HPS_API File
38059  {
38060  public:
38066  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
38067 
38068  private:
38070  File();
38071  };
38072 
38073 private:
38075  Shader();
38076 };
38077 
38078 
38080 class HPS_API ShaderKit : public Object
38081 {
38082 public:
38084  ShaderKit();
38085 
38088  ShaderKit(ShaderKit const & in_kit);
38089 
38093  ShaderKit(ShaderKit && in_that);
38094 
38098  ShaderKit & operator=(ShaderKit && in_that);
38099 
38100  virtual ~ShaderKit();
38101 
38102  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
38103 
38106  void Set(ShaderKit const & in_kit);
38107 
38110  void Show(ShaderKit & out_kit) const;
38111 
38115  ShaderKit & operator=(ShaderKit const & in_kit);
38116 
38119  bool Empty() const;
38120 
38124  bool Equals(ShaderKit const & in_kit) const;
38125 
38129  bool operator==(ShaderKit const & in_kit) const;
38130 
38134  bool operator!=(ShaderKit const & in_kit) const;
38135 
38139  ShaderKit & SetSource(char const * in_source);
38140 
38147  ShaderKit & SetMultitexture(bool in_state);
38148 
38152  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38153 
38157  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
38158 
38161  ShaderKit & UnsetSource();
38162 
38166  ShaderKit & UnsetMultitexture();
38167 
38170  ShaderKit & UnsetParameterizationSource();
38171 
38174  ShaderKit & UnsetTransformMatrix();
38175 
38178  ShaderKit & UnsetEverything();
38179 
38183  bool ShowSource(UTF8 & out_source) const;
38184 
38190  bool ShowMultitexture(bool & out_state) const;
38191 
38195  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
38196 
38200  bool ShowTransformMatrix(MatrixKit & out_transform) const;
38201 };
38202 
38203 
38205 class HPS_API ShaderDefinition : public Definition
38206 {
38207 public:
38209  ShaderDefinition();
38210 
38215  ShaderDefinition(Definition const & in_that);
38216 
38219  ShaderDefinition(ShaderDefinition const & in_that);
38220 
38224  ShaderDefinition & operator=(ShaderDefinition const & in_that);
38225 
38229  ShaderDefinition(ShaderDefinition && in_that);
38230 
38234  ShaderDefinition & operator=(ShaderDefinition && in_that);
38235 
38236  ~ShaderDefinition();
38237 
38238  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
38239 
38242  void Set(ShaderKit const & in_kit);
38243 
38246  void Show(ShaderKit & out_kit) const;
38247 };
38248 
38249 
38250 
38251 
38255 
38257 {
38258 public:
38261 
38265 
38270 
38275 
38276  virtual ~CutGeometryGatheringOptionsKit();
38277 
38278  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
38279 
38283  static CutGeometryGatheringOptionsKit GetDefault();
38284 
38287  void Set(CutGeometryGatheringOptionsKit const & in_kit);
38288 
38291  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
38292 
38297 
38300  bool Empty() const;
38301 
38305  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
38306 
38310  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
38311 
38315  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
38316 
38317 
38321  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
38322 
38326  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
38327 
38332 
38333 
38336  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
38337 
38340  CutGeometryGatheringOptionsKit & UnsetOffset();
38341 
38344  CutGeometryGatheringOptionsKit & UnsetLevel();
38345 
38348  CutGeometryGatheringOptionsKit & UnsetEverything();
38349 
38350 
38354  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
38355 
38359  bool ShowOffset(size_t & out_offset) const;
38360 
38364  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
38365 };
38366 
38368 class HPS_API SearchOptionsKit : public Object
38369 {
38370 public:
38372  SearchOptionsKit();
38373 
38376  SearchOptionsKit(SearchOptionsKit const & in_kit);
38377 
38381  SearchOptionsKit(SearchOptionsKit && in_that);
38382 
38386  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
38387 
38388  virtual ~SearchOptionsKit();
38389 
38390  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
38391 
38395  static SearchOptionsKit GetDefault();
38396 
38399  void Set(SearchOptionsKit const & in_kit);
38400 
38403  void Show(SearchOptionsKit & out_kit) const;
38404 
38408  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
38409 
38412  bool Empty() const;
38413 
38417  bool Equals(SearchOptionsKit const & in_kit) const;
38418 
38422  bool operator==(SearchOptionsKit const & in_kit) const;
38423 
38427  bool operator!=(SearchOptionsKit const & in_kit) const;
38428 
38432  SearchOptionsKit & SetCriteria(Search::Type in_request);
38433 
38437  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
38438 
38442  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
38443 
38448  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
38449 
38453  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
38454 
38457  SearchOptionsKit & UnsetBehavior();
38458 
38461  SearchOptionsKit & UnsetCriteria();
38462 
38465  SearchOptionsKit & UnsetSearchSpace();
38466 
38469  SearchOptionsKit & UnsetEverything();
38470 
38474  bool ShowBehavior(Search::Behavior & out_behavior) const;
38475 
38479  bool ShowCriteria(SearchTypeArray & out_types) const;
38480 
38484  bool ShowSearchSpace(Search::Space & out_search_space) const;
38485 };
38486 
38490 class HPS_API TreeContext : public Object
38491 {
38492 public:
38495  TreeContext(bool in_create = true);
38496 
38499  TreeContext(TreeContext const & in_that);
38500 
38504  TreeContext(TreeContext && in_that);
38505 
38509  TreeContext & operator=(TreeContext && in_that);
38510 
38512  virtual ~TreeContext();
38513 
38514  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
38515 
38519  TreeContext & operator=(TreeContext const & in_that);
38520 
38524  bool Equals(TreeContext const & in_that) const;
38525 
38529  bool operator==(TreeContext const & in_that) const;
38530 
38534  bool operator!=(TreeContext const & in_that) const;
38535 
38536 };
38537 
38539 class HPS_API SelectionOptionsKit : public Object
38540 {
38541 public:
38544 
38547  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
38548 
38553 
38557  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
38558 
38559  virtual ~SelectionOptionsKit();
38560 
38561  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
38562 
38566  static SelectionOptionsKit GetDefault();
38567 
38570  void Set(SelectionOptionsKit const & in_kit);
38571 
38574  void Show(SelectionOptionsKit & out_kit) const;
38575 
38579  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
38580 
38583  bool Empty() const;
38584 
38588  bool Equals(SelectionOptionsKit const & in_kit) const;
38589 
38593  bool operator==(SelectionOptionsKit const & in_kit) const;
38594 
38598  bool operator!=(SelectionOptionsKit const & in_kit) const;
38599 
38607  SelectionOptionsKit & SetProximity(float in_proximity);
38608 
38614  SelectionOptionsKit & SetLevel(Selection::Level in_level);
38615 
38620  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
38621 
38630  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
38631 
38639  SelectionOptionsKit & SetSorting(bool in_sorted);
38640 
38646  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
38647 
38653  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
38654 
38659  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
38660 
38665  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
38666 
38671  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
38672 
38679  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
38680 
38687  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
38688 
38695  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
38696 
38703  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
38704 
38707  SelectionOptionsKit & UnsetProximity();
38708 
38711  SelectionOptionsKit & UnsetLevel();
38712 
38715  SelectionOptionsKit & UnsetInternalLimit();
38716 
38719  SelectionOptionsKit & UnsetRelatedLimit();
38720 
38723  SelectionOptionsKit & UnsetSorting();
38724 
38727  SelectionOptionsKit & UnsetAlgorithm();
38728 
38731  SelectionOptionsKit & UnsetGranularity();
38732 
38735  SelectionOptionsKit & UnsetScope();
38736 
38739  SelectionOptionsKit & UnsetTreeContext();
38740 
38743  SelectionOptionsKit & UnsetExtentCullingRespected();
38744 
38747  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
38748 
38751  SelectionOptionsKit & UnsetFrustumCullingRespected();
38752 
38755  SelectionOptionsKit & UnsetVectorCullingRespected();
38756 
38757 
38760  SelectionOptionsKit & UnsetEverything();
38761 
38765  bool ShowProximity(float & out_proximity) const;
38766 
38770  bool ShowLevel(Selection::Level & out_level) const;
38771 
38775  bool ShowInternalLimit(size_t & out_limit) const;
38776 
38780  bool ShowRelatedLimit(size_t & out_limit) const;
38781 
38785  bool ShowSorting(bool & out_sorted) const;
38786 
38790  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38791 
38795  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38796 
38800  bool ShowScope(KeyPath & out_start_path) const;
38801 
38805  bool ShowTreeContext(TreeContext & out_tree_context) const;
38806 
38810  bool ShowExtentCullingRespected(bool & out_state) const;
38811 
38815  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38816 
38820  bool ShowFrustumCullingRespected(bool & out_state) const;
38821 
38825  bool ShowVectorCullingRespected(bool & out_state) const;
38826 };
38827 
38828 
38829 
38833 class HPS_API SelectionOptionsControl : public Control
38834 {
38835 public:
38838  explicit SelectionOptionsControl(WindowKey const & in_window);
38839 
38843 
38848 
38852  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
38853 
38855 
38856  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
38857 
38861  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
38862 
38868  SelectionOptionsControl & SetProximity(float in_proximity);
38869 
38875  SelectionOptionsControl & SetLevel(Selection::Level in_level);
38876 
38883  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
38884 
38893  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
38894 
38902  SelectionOptionsControl & SetSorting(bool in_sorted);
38903 
38909  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
38910 
38916  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
38917 
38924  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
38925 
38932  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
38933 
38940  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
38941 
38948  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
38949 
38950  // there is no way to unset default values, intentionally
38951 
38955  bool ShowProximity(float & out_proximity) const;
38956 
38960  bool ShowLevel(Selection::Level & out_level) const;
38961 
38965  bool ShowInternalLimit(size_t & out_limit) const;
38966 
38970  bool ShowRelatedLimit(size_t & out_limit) const;
38971 
38975  bool ShowSorting(bool & out_sorted) const;
38976 
38980  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38981 
38985  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38986 
38990  bool ShowExtentCullingRespected(bool & out_state) const;
38991 
38995  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38996 
39000  bool ShowFrustumCullingRespected(bool & out_state) const;
39001 
39005  bool ShowVectorCullingRespected(bool & out_state) const;
39006 
39007 private:
39010 };
39011 
39012 
39013 
39015 class HPS_API SelectionItem : public Object
39016 {
39017 public:
39019  SelectionItem();
39020 
39023  SelectionItem(SelectionItem const & in_that);
39024 
39028  SelectionItem(SelectionItem && in_that);
39029 
39033  SelectionItem & operator=(SelectionItem && in_that);
39034 
39035  virtual ~SelectionItem();
39036 
39037  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
39038 
39041  void Set(SelectionItem const & in_that);
39042 
39046  SelectionItem & operator=(SelectionItem const & in_that);
39047 
39051  bool Equals(SelectionItem const & in_that) const;
39052 
39056  bool operator==(SelectionItem const & in_that) const;
39057 
39061  bool operator!=(SelectionItem const & in_that) const;
39062 
39066  bool ShowSelectionLevel(Selection::Level & out_level) const;
39067 
39071  bool ShowSelectedItem(Key & out_selection) const;
39072 
39076  bool ShowPath(KeyPath & out_path) const;
39077 
39081  bool ShowFaces(SizeTArray & out_faces) const;
39082 
39086  bool ShowVertices(SizeTArray & out_vertices) const;
39087 
39092  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
39093 
39097  bool ShowCharacters(SizeTArray & out_characters) const;
39098 
39102  bool ShowSelectionPosition(WindowPoint & out_location) const;
39103 
39107  bool ShowSelectionPosition(WorldPoint & out_location) const;
39108 
39109 };
39110 
39112 class HPS_API SelectionResultsIterator : public Object
39113 {
39114 public:
39117 
39122 
39127 
39131  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
39132 
39134 
39135  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
39136 
39140  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
39141 
39144  void Set(SelectionResultsIterator const & in_that);
39145 
39147  void Next();
39148 
39151  SelectionResultsIterator & operator++();
39152 
39155  SelectionResultsIterator operator++(int in_val);
39156 
39159  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
39160 
39163  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
39164 
39165 
39168  bool IsValid() const;
39169 
39171  void Reset();
39172 
39175  SelectionItem GetItem() const;
39176 
39179  SelectionItem operator*() const;
39180 
39181 
39182 };
39183 
39187 class HPS_API SelectionResults : public Object
39188 {
39189 public:
39191  SelectionResults();
39192 
39195  SelectionResults(SelectionResults const & in_that);
39196 
39200  SelectionResults(SelectionResults && in_that);
39201 
39205  SelectionResults & operator=(SelectionResults && in_that);
39206 
39207  ~SelectionResults();
39208 
39209  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
39210 
39213  void Assign(SelectionResults const & in_that);
39214 
39218  SelectionResults & operator=(SelectionResults const & in_that);
39219 
39223  bool Equals(SelectionResults const & in_that) const;
39224 
39228  bool operator==(SelectionResults const & in_that) const;
39229 
39233  bool operator!=(SelectionResults const & in_that) const;
39234 
39236  virtual void Reset();
39237 
39240  Selection::Level GetSelectionLevel() const;
39241 
39244  size_t GetCount() const;
39245 
39248  SelectionResultsIterator GetIterator() const;
39249 
39255  bool Union(SelectionResults const & in_that);
39256 
39261  bool Intersect(SelectionResults const & in_that);
39262 
39268  bool SymmetricDifference(SelectionResults const & in_that);
39269 
39274  bool Difference(SelectionResults const & in_that);
39275 
39278  void Copy(SelectionResults const & in_that);
39279 };
39280 
39283 class HPS_API SelectionControl : public Object
39284 {
39285 public:
39288  explicit SelectionControl(WindowKey const & in_window);
39289 
39292  SelectionControl(SelectionControl const & in_that);
39293 
39297  SelectionControl(SelectionControl && in_that);
39298 
39302  SelectionControl & operator=(SelectionControl && in_that);
39303 
39304  ~SelectionControl();
39305 
39306  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
39307 
39311  SelectionControl & operator=(SelectionControl const & in_that);
39312 
39318  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39319 
39324  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
39325 
39331  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39332 
39337  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
39338 
39344  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39345 
39350  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
39351 
39358  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39359 
39365  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39366 
39372  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39373 
39378  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
39379 
39386  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
39387 
39393  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
39394 
39395 
39396  //Object space selections
39397 
39403  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39404 
39409  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
39410 
39416  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39417 
39422  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
39423 
39424 
39431  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39432 
39438  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
39439 
39440 
39447  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
39448 
39454  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
39455 
39456 private:
39458  SelectionControl();
39459 };
39460 
39461 
39462 
39464 class HPS_API HighlightOptionsKit : public Object
39465 {
39466 public:
39469 
39472  HighlightOptionsKit(char const * in_style_name);
39473 
39477  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
39478 
39481  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
39482 
39487 
39491  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
39492 
39493  virtual ~HighlightOptionsKit();
39494 
39495  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
39496 
39500  static HighlightOptionsKit GetDefault();
39501 
39504  void Set(HighlightOptionsKit const & in_kit);
39505 
39508  void Show(HighlightOptionsKit & out_kit) const;
39509 
39513  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
39514 
39517  bool Empty() const;
39518 
39522  bool Equals(HighlightOptionsKit const & in_kit) const;
39523 
39527  bool operator==(HighlightOptionsKit const & in_kit) const;
39528 
39532  bool operator!=(HighlightOptionsKit const & in_kit) const;
39533 
39534 
39538  HighlightOptionsKit & SetStyleName(char const * in_style_name);
39539 
39543  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
39544 
39551  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
39552 
39558  HighlightOptionsKit & SetNotification(bool in_state);
39559 
39560 
39563  HighlightOptionsKit & UnsetStyleName();
39564 
39567  HighlightOptionsKit & UnsetSecondaryStyleName();
39568 
39571  HighlightOptionsKit & UnsetOverlay();
39572 
39575  HighlightOptionsKit & UnsetNotification();
39576 
39579  HighlightOptionsKit & UnsetEverything();
39580 
39581 
39585  bool ShowStyleName(UTF8 & out_style_name) const;
39586 
39590  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
39591 
39595  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
39596 
39600  bool ShowNotification(bool & out_state) const;
39601 };
39602 
39605 class HPS_API HighlightControl : public Control
39606 {
39607 public:
39610  explicit HighlightControl(WindowKey const & in_window);
39611 
39614  HighlightControl(HighlightControl const & in_that);
39615 
39619  HighlightControl(HighlightControl && in_that);
39620 
39624  HighlightControl & operator=(HighlightControl && in_that);
39625 
39626  ~HighlightControl();
39627 
39628  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
39629 
39633  HighlightControl & operator=(HighlightControl const & in_that);
39634 
39639  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
39640 
39645  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
39646 
39651  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
39652 
39657  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
39658 
39663  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
39664 
39669  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39670 
39675  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39676 
39681  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39682 
39687  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39688 
39693  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
39694 
39698  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
39699 
39702  HighlightControl & UnhighlightEverything();
39703 
39704 private:
39706  HighlightControl();
39707 };
39708 
39710 class HPS_API UpdateOptionsKit : public Object
39711 {
39712 public:
39714  UpdateOptionsKit();
39715 
39718  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
39719 
39723  UpdateOptionsKit(UpdateOptionsKit && in_that);
39724 
39728  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
39729 
39730  virtual ~UpdateOptionsKit();
39731 
39732  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
39733 
39737  static UpdateOptionsKit GetDefault();
39738 
39741  void Set(UpdateOptionsKit const & in_kit);
39742 
39745  void Show(UpdateOptionsKit & out_kit) const;
39746 
39750  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
39751 
39754  bool Empty() const;
39755 
39759  bool Equals(UpdateOptionsKit const & in_kit) const;
39760 
39764  bool operator==(UpdateOptionsKit const & in_kit) const;
39765 
39769  bool operator!=(UpdateOptionsKit const & in_kit) const;
39770 
39774  UpdateOptionsKit & SetUpdateControl(HPS::Window::UpdateControl in_control);
39775 
39779  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
39780 
39783  UpdateOptionsKit & UnsetUpdateControl();
39784 
39787  UpdateOptionsKit & UnsetTimeLimit();
39788 
39791  UpdateOptionsKit & UnsetEverything();
39792 
39793 
39797  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39798 
39802  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39803 
39804 };
39805 
39806 
39807 
39813 class HPS_API UpdateOptionsControl : public Control
39814 {
39815 public:
39818  explicit UpdateOptionsControl(WindowKey const & in_window);
39819 
39822  UpdateOptionsControl(UpdateOptionsControl const & in_that);
39823 
39828 
39832  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
39833 
39835 
39836  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
39837 
39841  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
39842 
39846  UpdateOptionsControl & SetUpdateControl(HPS::Window::UpdateControl in_control);
39847 
39851  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
39852 
39855  UpdateOptionsControl & UnsetUpdateControl();
39856 
39859  UpdateOptionsControl & UnsetTimeLimit();
39860 
39863  UpdateOptionsControl & UnsetEverything();
39864 
39868  bool ShowUpdateControl(HPS::Window::UpdateControl & out_control) const;
39869 
39873  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
39874 
39875 private:
39878 };
39879 
39882 class HPS_API World : public Object
39883 {
39884 public:
39888  World(char const * in_license);
39889 
39891  ~World();
39892 
39893  HPS::Type ObjectType() const {return HPS::Type::World;};
39894 
39899  World & SetMaterialLibraryDirectory(char const * in_directory);
39900 
39905  World & SetFontDirectory(char const * in_directory);
39906 
39912  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
39913 
39918  World & SetFontDirectories(UTF8Array const & in_directories);
39919 
39925  World & SetDriverConfigFile(char const * in_filename);
39926 
39932  World & SetExchangeLibraryDirectory(char const * in_directory);
39933 
39939  World & SetPublishResourceDirectory(char const * in_directory);
39940 
39945  World & SetParasolidSchemaDirectory(char const * in_directory);
39946 
39951  World & SetRealDWGDirectory(char const * in_directory);
39952 
39955  World & UnsetMaterialLibraryDirectory();
39956 
39959  World & UnsetFontDirectories();
39960 
39963  World & UnsetDriverConfigFile();
39964 
39967  World & UnsetExchangeLibraryDirectory();
39968 
39971  World & UnsetPublishResourceDirectory();
39972 
39975  World & UnsetParasolidSchemaDirectory();
39976 
39979  World & UnsetRealDWGDirectory();
39980 
39984  bool ShowLicense(UTF8 & out_license) const;
39985 
39989  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
39990 
39994  bool ShowFontDirectories(UTF8Array & out_directories) const;
39995 
39999  bool ShowDriverConfigFile(UTF8 & out_filename) const;
40000 
40004  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
40005 
40009  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
40010 
40014  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
40015 
40019  bool ShowRealDWGDirectory(UTF8 & out_directory) const;
40020 
40021 
40022 private:
40024  World();
40025 
40027  virtual void Reset() {}
40028 };
40029 
40030 
40046 class HPS_API EmergencyHandler
40047 {
40048 public:
40049 
40052 
40053  virtual ~EmergencyHandler();
40054 
40056  intptr_t GetClassID() const;
40057 
40060  virtual EmergencyHandler * Clone() const = 0;
40061 
40065  virtual void Handle(const char * message, HPS::Emergency::Code code) const = 0;
40066 
40067  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
40068  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
40069 };
40070 
40071 
40074 class HPS_API Database
40075 {
40076 public:
40081  static void Execute(bool in_once=true);
40082 
40085  static Time GetTime();
40086 
40088  static void Sleep(Time milliseconds);
40089 
40114  static void RelinquishMemory();
40115 
40116 
40142  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
40143 
40151  static void Reset();
40152 
40154  static void Synchronize();
40155 
40158  static WindowKeyArray GetWindowKeys();
40159 
40162  static SegmentKeyArray GetRootSegments();
40163 
40166  static PortfolioKeyArray GetPortfolios();
40167 
40172  static PortfolioKey const GetMaterialLibraryPortfolio();
40173 
40179  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
40180 
40185  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
40186 
40190  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
40191 
40195  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
40196 
40203  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
40204 
40210  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
40211 
40217  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
40218 
40223  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
40224 
40227  static SegmentKey CreateRootSegment();
40228 
40231  static PortfolioKey CreatePortfolio();
40232 
40235  static EventDispatcher CreateEventDispatcher();
40236 
40240  static EventDispatcher CreateEventDispatcher(char const * in_name);
40241 
40247  static size_t SelectByShell(ShellKit const & in_shell,
40248  SelectionOptionsKit const & in_options,
40249  SelectionResults & out_results);
40250 
40256  static size_t SelectByShell(ShellKey const & in_shell,
40257  SelectionOptionsKit const & in_options,
40258  SelectionResults & out_results);
40259 
40266  static size_t SelectByVolume(SimpleCuboid const & in_volume,
40267  SelectionOptionsKit const & in_options,
40268  SelectionResults & out_results);
40269 
40276  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
40277  SelectionOptionsKit const & in_options,
40278  SelectionResults & out_results);
40279 
40282  static EventDispatcher const & GetEventDispatcher();
40283 
40284 
40288  static bool GetInformationEventFilter(HPS::Info::Code in_code);
40289 
40293  static bool GetWarningEventFilter(HPS::Info::Code in_code);
40294 
40298  static bool GetErrorEventFilter(HPS::Info::Code in_code);
40299 
40304  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
40305 
40310  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
40311 
40316  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
40317 
40318 
40321  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
40322 
40324  static void UnsetEmergencyHandler();
40325 
40328  static size_t GetSoftMemoryLimit();
40329 
40333  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
40334 
40338  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
40339 
40340 private:
40342  Database();
40343 };
40344 
40345 
40349 
40350 
40351 
40353 class HPS_API EventDispatcher : public Object
40354 {
40355 public:
40358  EventDispatcher();
40359 
40362  EventDispatcher(EventDispatcher const & in_that);
40363 
40367  EventDispatcher(EventDispatcher && in_that);
40368 
40372  EventDispatcher & operator=(EventDispatcher && in_that);
40373 
40374  virtual ~EventDispatcher();
40375 
40376  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
40377 
40381  EventDispatcher & operator=(EventDispatcher const & in_that);
40382 
40386  bool Equals(EventDispatcher const & in_that) const;
40387 
40391  bool operator==(EventDispatcher const & in_that) const;
40392 
40396  bool operator!=(EventDispatcher const & in_that) const;
40397 
40402  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
40403 
40408  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
40409 
40414  bool UnSubscribe(EventHandler const & in_handler) const;
40415 
40420  bool UnSubscribe(intptr_t in_type) const;
40421 
40425  bool InjectEvent(Event const & in_event) const;
40426 
40431  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
40432 
40435  void Shutdown() const;
40436 
40439  bool IsShutdown() const;
40440 
40441 
40444  void SetName(char const * in_name) const;
40445 
40448  void ShowName(UTF8 & out_name) const;
40449 
40450 private:
40452  virtual void Reset() {}
40453 };
40454 
40455 
40458 class HPS_API EventHandler : public Object
40459 {
40460 public:
40462  EventHandler();
40463 
40466  EventHandler(EventHandler const & in_that);
40467 
40471  EventHandler(EventHandler && in_that);
40472 
40476  EventHandler & operator=(EventHandler && in_that);
40477 
40481  EventHandler & operator=(EventHandler const & in_that);
40482 
40483  virtual ~EventHandler();
40484 
40485  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
40486 
40491  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40492 
40497  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
40498 
40502  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
40503 
40505  void UnSubscribeEverything() const;
40506 
40508  virtual void Reset() { UnSubscribeEverything(); }
40509 
40512  void Shutdown();
40513 
40516  enum class HandleResult
40517  {
40518  Handled,
40519  NotHandled
40520  };
40521 
40526  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
40527 };
40528 
40529 
40530 
40532 class HPS_API TimerTickEvent : public Event
40533 {
40534 public:
40537  {
40538  channel = GetClassID();
40539  consumable = false;
40540  }
40541 
40542 
40545  TimerTickEvent(Event const & in_event) : Event(in_event)
40546  {
40547  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
40548  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40549  }
40550 
40551  ~TimerTickEvent();
40552 
40555  Event * Clone() const
40556  {
40557  TimerTickEvent * new_event = new TimerTickEvent(*this);
40558  return new_event;
40559  }
40560 
40564  virtual bool Drop(Event const * in_that_event) const
40565  {
40566  HPS_UNREFERENCED(in_that_event);
40567  return true;
40568  }
40569 
40570  virtual intptr_t Freshen() const {
40571  return GetClassID();
40572  }
40573 };
40574 
40576 class HPS_API HighlightEvent : public Event
40577 {
40578 public:
40579  enum class Action
40580  {
40581  None = 0,
40582  Highlight,
40583  Unhighlight,
40584  };
40585 
40588  {
40589  channel = GetClassID();
40590  consumable = false;
40591  action = Action::None;
40592  }
40593 
40594  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
40595  : Event(), action(in_action), results(in_results), options(in_options)
40596  {
40597  channel = GetClassID();
40598  consumable = false;
40599  }
40600 
40603  HighlightEvent(Event const & in_event) : Event(in_event)
40604  {
40605  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
40606  {
40607  auto that = static_cast<HighlightEvent const &>(in_event);
40608  action = that.action;
40609  results = that.results;
40610  options = that.options;
40611  }
40612  else
40613  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40614  }
40615 
40616  ~HighlightEvent();
40617 
40620  Event * Clone() const
40621  {
40622  HighlightEvent * new_event = new HighlightEvent(*this);
40623  return new_event;
40624  }
40625 
40626  Action action;
40627  SelectionResults results;
40628  HighlightOptionsKit options;
40629 };
40630 
40632 class HPS_API InformationEvent : public Event
40633 {
40634 public:
40636  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40637 
40640  InformationEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40641 
40645  InformationEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40646 
40649  InformationEvent(Event const & in_event) : Event(in_event)
40650  {
40651  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
40652  {
40653  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
40654  message = event->message;
40655  code = event->code;
40656  }
40657  else
40658  {
40659  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40660  }
40661  }
40662 
40663  ~InformationEvent();
40664 
40667  Event * Clone() const
40668  {
40669  InformationEvent * new_event = new InformationEvent(*this);
40670  return new_event;
40671  }
40672 
40676  virtual bool Equals(InformationEvent const & in_that) const
40677  {
40678  return message == in_that.message && code == in_that.code;
40679  }
40680 
40684  virtual bool operator== (InformationEvent const & in_that) const
40685  {
40686  return Equals(in_that);
40687  }
40688 
40692  virtual bool operator!= (InformationEvent const & in_that) const
40693  {
40694  return !Equals(in_that);
40695  }
40696 
40699 };
40700 
40701 
40703 class HPS_API WarningEvent : public Event
40704 {
40705 public:
40707  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40708 
40711  WarningEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40712 
40716  WarningEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40717 
40720  WarningEvent(Event const & in_event) : Event(in_event)
40721  {
40722  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
40723  {
40724  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
40725  message = event->message;
40726  code = event->code;
40727  }
40728  else
40729  {
40730  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40731  }
40732  }
40733 
40734  ~WarningEvent();
40735 
40738  Event * Clone() const
40739  {
40740  WarningEvent * new_event = new WarningEvent(*this);
40741  return new_event;
40742  }
40743 
40747  virtual bool Equals(WarningEvent const & in_that) const
40748  {
40749  return message == in_that.message && code == in_that.code;
40750  }
40751 
40755  virtual bool operator== (WarningEvent const & in_that) const
40756  {
40757  return Equals(in_that);
40758  }
40759 
40763  virtual bool operator!= (WarningEvent const & in_that) const
40764  {
40765  return !Equals(in_that);
40766  }
40767 
40770 };
40771 
40772 
40774 class HPS_API ErrorEvent : public Event
40775 {
40776 public:
40778  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40779 
40782  ErrorEvent(char const * in_message) : Event(), message(in_message), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
40783 
40787  ErrorEvent(char const * in_message, HPS::Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
40788 
40791  ErrorEvent(Event const & in_event) : Event(in_event)
40792  {
40793  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
40794  {
40795  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
40796  message = event->message;
40797  code = event->code;
40798  }
40799  else
40800  {
40801  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40802  }
40803  }
40804 
40805  ~ErrorEvent();
40806 
40809  Event * Clone() const
40810  {
40811  ErrorEvent * new_event = new ErrorEvent(*this);
40812  return new_event;
40813  }
40814 
40818  virtual bool Equals(ErrorEvent const & in_that) const
40819  {
40820  return message == in_that.message && code == in_that.code;
40821  }
40822 
40826  virtual bool operator== (ErrorEvent const & in_that) const
40827  {
40828  return Equals(in_that);
40829  }
40830 
40834  virtual bool operator!= (ErrorEvent const & in_that) const
40835  {
40836  return !Equals(in_that);
40837  }
40838 
40841 };
40842 
40843 
40845 class HPS_API StandAloneWindowEvent : public Event
40846 {
40847 public:
40848 
40851  enum class Action
40852  {
40853  Unknown,
40854  Close,
40855  FocusIn,
40856  FocusOut,
40857  };
40858 
40860  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
40861 
40862 
40865  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
40866 
40869  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
40870  {
40871  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40872  {
40873  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
40874  action = event->action;
40875  }
40876  else
40877  {
40878  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40879  }
40880  }
40881 
40883 
40886  Event * Clone() const
40887  {
40888  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
40889  return new_event;
40890  }
40891 
40895  virtual bool Equals(StandAloneWindowEvent const & in_that) const
40896  {
40897  return action == in_that.action;
40898  }
40899 
40903  virtual bool operator== (StandAloneWindowEvent const & in_that) const
40904  {
40905  return Equals(in_that);
40906  }
40907 
40911  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
40912  {
40913  return !Equals(in_that);
40914  }
40915 
40917 };
40918 
40920 class HPS_API FocusLostEvent : public Event
40921 {
40922 public:
40925  Event()
40926  { channel = GetClassID(); }
40927 
40928  ~FocusLostEvent() {};
40929 
40932  Event * Clone() const
40933  {
40934  FocusLostEvent * new_event = new FocusLostEvent(*this);
40935  return new_event;
40936  }
40937 };
40938 
40939 
40941 class HPS_API UpdateCompletedEvent : public Event
40942 {
40943 public:
40945  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
40946 
40948  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
40949 
40952  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
40953  {
40954  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
40955  {
40956  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
40957  update_time = event->update_time;
40958  }
40959  else
40960  {
40961  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
40962  }
40963  }
40964 
40965  virtual ~UpdateCompletedEvent();
40966 
40969  Event * Clone() const
40970  {
40971  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
40972  return new_event;
40973  }
40974 
40975  Time update_time;
40976 };
40977 
40979 class HPS_API ImportStatusEvent : public Event
40980 {
40981 public:
40984  : Event()
40985  , import_status_message(HPS::UTF8())
40986  { channel = GetClassID(); }
40987 
40988  ImportStatusEvent(char const * in_message)
40989  : Event()
40990  , import_status_message(in_message)
40991  { channel = GetClassID(); }
40992 
40995  ImportStatusEvent(Event const & in_event) : Event(in_event)
40996  {
40997  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
40998  {
40999  auto event = static_cast<ImportStatusEvent const &>(in_event);
41000  import_status_message = event.import_status_message;
41001  }
41002  else
41003  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41004  }
41005 
41006  ~ImportStatusEvent() {};
41007 
41010  Event * Clone() const
41011  {
41012  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
41013  return new_event;
41014  }
41015 
41016  HPS::UTF8 import_status_message;
41017 };
41018 
41020 class HPS_API ModifierKeys
41021 {
41022 public:
41024  ModifierKeys() : modifiers(_key_none) {}
41025 
41029  bool Equals(ModifierKeys const & in_that) const
41030  {
41031  return modifiers == in_that.modifiers;
41032  }
41033 
41037  bool operator== (ModifierKeys const & in_that) const
41038  {
41039  return Equals(in_that);
41040  }
41041 
41045  bool operator!= (ModifierKeys const & in_that) const
41046  {
41047  return !Equals(in_that);
41048  }
41049 
41052  bool None() const { return modifiers == _key_none; }
41053 
41056  bool Shift() const { return (modifiers & _key_shift) != 0; }
41057 
41060  bool Control() const { return (modifiers & _key_control) != 0; }
41061 
41064  bool Alt() const { return (modifiers & _key_alt) != 0; }
41065 
41068  bool Meta() const { return (modifiers & _key_meta) != 0; }
41069 
41070 
41074  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41075 
41079  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
41080 
41081 
41084  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
41085 
41088  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
41089 
41092  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
41093 
41096  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
41097 
41101  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
41102  {
41103  ModifierKeys ret;
41104  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41105  return ret;
41106  }
41107 
41111  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
41112  {
41113  ModifierKeys ret;
41114  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41115  return ret;
41116  }
41117 
41121  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
41122 
41126  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
41127 
41128 
41131  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
41132 
41135  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
41136 
41139  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
41140 
41143  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
41144 
41145 protected:
41146 
41150  {
41151  _key_none = 0x0000,
41152  _key_shift = 0x0001,
41153  _key_control = 0x0002,
41154  _key_alt = 0x0004,
41155  _key_meta = 0x0008,
41156  };
41157 
41158  int modifiers;
41159 };
41160 
41161 
41164 class HPS_API InputEvent : public Event
41165 {
41166 public:
41167 
41169  InputEvent() : Event() { channel = GetClassID(); }
41170 
41173  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
41174 
41175  ~InputEvent();
41176 
41179  Event * Clone() const
41180  {
41181  InputEvent * new_event = new InputEvent(*this);
41182  return new_event;
41183  }
41184 
41188  virtual bool Equals(InputEvent const & in_that) const
41189  {
41190  return ModifierKeyState == in_that.ModifierKeyState;
41191  }
41192 
41196  virtual bool operator== (InputEvent const & in_that) const
41197  {
41198  return Equals(in_that);
41199  }
41200 
41204  virtual bool operator!= (InputEvent const & in_that) const
41205  {
41206  return !Equals(in_that);
41207  }
41208 
41213  {
41214  return ModifierKeyState;
41215  }
41216 
41218 };
41219 
41221 class HPS_API TouchEvent : public InputEvent
41222 {
41223 public:
41226  enum class Action
41227  {
41228  TouchDown,
41229  TouchUp,
41230  Move,
41231  };
41232 
41234  TouchEvent() : InputEvent() { channel = GetClassID(); }
41235 
41240  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
41241  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41242 
41248  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
41249  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41250 
41257  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
41258  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41259 
41260 
41263  TouchEvent(Event const & in_event) : InputEvent()
41264  {
41265  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
41266  {
41267  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
41268  channel = GetClassID();
41269  CurrentAction = event->CurrentAction;
41270  Touches = event->Touches;
41271  ModifierKeyState = event->ModifierKeyState;
41272  }
41273  else
41274  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
41275  }
41276 
41277  ~TouchEvent();
41278 
41279 
41282  Event * Clone() const
41283  {
41284  TouchEvent * new_event = new TouchEvent(*this);
41285  return new_event;
41286  }
41287 
41291  virtual bool Equals(TouchEvent const & in_that) const
41292  {
41293  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
41294  }
41295 
41299  virtual bool operator== (TouchEvent const & in_that) const
41300  {
41301  return Equals(in_that);
41302  }
41303 
41307  virtual bool operator!= (TouchEvent const & in_that) const
41308  {
41309  return !Equals(in_that);
41310  }
41311 
41315  virtual bool Drop(Event const * in_that_event) const
41316  {
41317  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
41318 
41319  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
41320  && Touches.size() == that_touch_event->Touches.size() )
41321  {
41322  TouchArray these_touches = Touches;
41323  TouchArray those_touches = that_touch_event->Touches;
41324 
41325  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41326  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41327 
41328  for (size_t i = 0 ; i < these_touches.size() ; i++)
41329  {
41330  if (these_touches[i].ID != those_touches[i].ID)
41331  return false;
41332  }
41333  return true;
41334  }
41335 
41336  return false;
41337  }
41338 
41342  void SetTouches(size_t in_touch_count, Touch const in_touches[])
41343  {
41344  Touches.assign(in_touches, in_touches + in_touch_count);
41345  }
41346 
41349  void SetTouches(HPS::TouchArray const & in_touches)
41350  {
41351  Touches = in_touches;
41352  }
41353 
41355  HPS::TouchArray Touches;
41356 
41357 private:
41363  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
41364  {
41365  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
41366  }
41367 };
41368 
41369 
41371 class HPS_API MouseButtons
41372 {
41373 public:
41375  MouseButtons() : buttons(_button_none) {}
41376 
41380  bool Equals(MouseButtons const & in_that) const
41381  {
41382  return buttons == in_that.buttons;
41383  }
41384 
41388  bool operator== (MouseButtons const & in_that) const
41389  {
41390  return Equals(in_that);
41391  }
41392 
41396  bool operator!= (MouseButtons const & in_that) const
41397  {
41398  return !Equals(in_that);
41399  }
41400 
41403  bool None() const { return buttons == _button_none; }
41404 
41407  bool Left() const { return (buttons & _button_left) != 0; }
41408 
41411  bool Right() const { return (buttons & _button_right) != 0; }
41412 
41415  bool Middle() const { return (buttons & _button_middle) != 0; }
41416 
41419  bool X1() const { return (buttons & _button_x1) != 0; }
41420 
41423  bool X2() const { return (buttons & _button_x2) != 0; }
41424 
41425 
41429  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41430 
41434  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
41435 
41438  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
41439 
41442  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
41443 
41446  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
41447 
41450  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
41451 
41454  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
41455 
41459  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
41460  {
41461  MouseButtons ret;
41462  ret.buttons = buttons | in_buttons_to_merge.buttons;
41463  return ret;
41464  }
41465 
41469  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
41470  {
41471  MouseButtons ret;
41472  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41473  return ret;
41474  }
41475 
41479  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
41480 
41484  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
41485 
41486 
41489  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
41490 
41493  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
41494 
41497  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
41498 
41501  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
41502 
41505  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
41506 
41507 protected:
41508 
41511  enum Buttons
41512  {
41513  _button_none = 0x0000,
41514  _button_left = 0x0001,
41515  _button_right = 0x0002,
41516  _button_middle = 0x0004,
41517  _button_x1 = 0x0008,
41518  _button_x2 = 0x0010
41519  };
41520 
41521  int buttons;
41522 };
41523 
41525 class HPS_API MouseEvent : public InputEvent
41526 {
41527 public:
41528 
41531  enum class Action
41532  {
41533  ButtonUp,
41534  ButtonDown,
41535  Move,
41536  Scroll,
41537  Enter,
41538  Leave
41539  };
41540 
41542  MouseEvent() : InputEvent() { channel = GetClassID(); }
41543 
41550  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41551  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41552 
41560  MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location = WindowPoint(0,0,0), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
41561  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41562 
41565  MouseEvent(Event const & in_event) : InputEvent()
41566  {
41567  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
41568  {
41569  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
41570  channel = GetClassID();
41571  CurrentAction = event->CurrentAction;
41572  Location = event->Location;
41573  CurrentButton = event->CurrentButton;
41574  WheelDelta = event->WheelDelta;
41575  ClickCount = event->ClickCount;
41576  }
41577  else
41578  {
41579  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41580  }
41581  }
41582 
41583  ~MouseEvent();
41584 
41587  Event * Clone() const
41588  {
41589  MouseEvent * new_event = new MouseEvent(*this);
41590  return new_event;
41591  }
41592 
41596  virtual bool Equals(MouseEvent const & in_that) const
41597  {
41598  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
41599  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
41600  && Location == in_that.Location && ClickCount == in_that.ClickCount;
41601  }
41602 
41606  virtual bool operator== (MouseEvent const & in_that) const
41607  {
41608  return Equals(in_that);
41609  }
41610 
41614  virtual bool operator!= (MouseEvent const & in_that) const
41615  {
41616  return !Equals(in_that);
41617  }
41618 
41622  virtual bool Drop(Event const * in_that_event) const
41623  {
41624  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
41625 
41626  if (CurrentAction == that_mouse_event->CurrentAction &&
41627  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41628  CurrentButton == that_mouse_event->CurrentButton)
41629  return true;
41630 
41631  return false;
41632  }
41633 
41634  virtual intptr_t Freshen() const {
41635 
41636  if (CurrentAction == Action::Move)
41637  return GetClassID();
41638 
41639  return 0;
41640  }
41641 
41645  float WheelDelta;
41646  size_t ClickCount;
41647 };
41648 
41649 
41651 class HPS_API KeyboardEvent : public InputEvent
41652 {
41653 public:
41656  enum class Action
41657  {
41658  None,
41659  KeyDown,
41660  KeyUp
41661  };
41662 
41664  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
41665 
41670  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41671 
41677  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
41678  : InputEvent(in_modifiers), CurrentAction(in_action)
41679  {
41680  channel = GetClassID();
41681  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41682  }
41683 
41688  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
41689  : InputEvent(in_modifiers), CurrentAction(in_action)
41690  {
41691  channel = GetClassID();
41692  KeyboardCodes = in_keyboardcodes;
41693  }
41694 
41697  KeyboardEvent(Event const & in_event) : InputEvent()
41698  {
41699  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
41700  {
41701  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
41702  channel = GetClassID();
41703  KeyboardCodes = event->KeyboardCodes;
41704  CurrentAction = event->CurrentAction;
41705  }
41706  else
41707  {
41708  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
41709  }
41710  }
41711 
41712  ~KeyboardEvent();
41713 
41716  Event * Clone() const
41717  {
41718  KeyboardEvent * new_event = new KeyboardEvent(*this);
41719  return new_event;
41720  }
41721 
41725  virtual bool Equals(KeyboardEvent const & in_that) const
41726  {
41727  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
41728  }
41729 
41733  virtual bool operator== (KeyboardEvent const & in_that) const
41734  {
41735  return Equals(in_that);
41736  }
41737 
41741  virtual bool operator!= (KeyboardEvent const & in_that) const
41742  {
41743  return !Equals(in_that);
41744  }
41745 
41749  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
41750  {
41751  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41752  }
41753 
41756  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
41757  {
41758  KeyboardCodes = in_keyboardcodes;
41759  }
41760 
41761  HPS::KeyboardCodeArray KeyboardCodes;
41763 };
41764 
41765 
41767 class HPS_API MouseState : public Object
41768 {
41769 public:
41771  MouseState();
41772 
41775  MouseState(MouseState const & in_that);
41776 
41780  MouseState(MouseState && in_that);
41781 
41785  MouseState & operator=(MouseState && in_that);
41786 
41787  ~MouseState();
41788 
41789  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
41790 
41793  void Assign(MouseState const & in_that);
41794 
41798  MouseState & operator=(MouseState const & in_that);
41799 
41803  bool Equals(MouseState const & in_that) const;
41804 
41808  bool operator== (MouseState const & in_that) const;
41809 
41813  bool operator!= (MouseState const & in_that) const;
41814 
41819  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
41820 
41827  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
41828 
41831  HPS::MouseEvent GetActiveEvent() const;
41832 
41836  HPS::WindowKey GetEventSource() const;
41837 
41841  HPS::KeyArray GetEventPath() const;
41842 
41845  MouseButtons GetButtons() const;
41846 
41849  WindowPoint GetLocation() const;
41850 
41853  ModifierKeys GetModifierKeys() const;
41854 
41857  void SetActiveEvent(MouseEvent const & in_event);
41858 
41861  void SetEventPath(KeyArray const & in_path);
41862 
41865  void SetButtons(MouseButtons in_buttons);
41866 
41869  void SetLocation(WindowPoint const & in_point);
41870 
41873  void SetModifierKeys(ModifierKeys in_modifiers);
41874 };
41875 
41876 
41877 
41879 class HPS_API TouchState : public Object
41880 {
41881 public:
41883  TouchState();
41884 
41887  TouchState(TouchState const & in_that);
41888 
41892  TouchState(TouchState && in_that);
41893 
41897  TouchState & operator=(TouchState && in_that);
41898 
41899  ~TouchState();
41900 
41901  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
41902 
41905  void Assign(TouchState const & in_that);
41906 
41910  TouchState & operator=(TouchState const & in_that);
41911 
41915  bool Equals(TouchState const & in_that) const;
41916 
41920  bool operator== (TouchState const & in_that) const;
41921 
41925  bool operator!= (TouchState const & in_that) const;
41926 
41932  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
41933 
41936  HPS::TouchEvent GetActiveEvent() const;
41937 
41941  HPS::WindowKey GetEventSource() const;
41942 
41946  HPS::KeyArray GetEventPath() const;
41947 
41950  size_t GetTouchCount() const;
41951 
41954  HPS::TouchArray GetTouches() const;
41955 
41958  ModifierKeys GetModifierKeys() const;
41959 
41962  void SetActiveEvent(TouchEvent const & in_event);
41963 
41966  void SetEventPath(KeyArray const & in_path);
41967 
41970  void SetTouches(TouchArray const & in_touches);
41971 
41974  void SetModifierKeys(ModifierKeys in_modifiers);
41975 };
41976 
41977 
41978 
41980 class HPS_API KeyboardState : public Object
41981 {
41982 public:
41984  KeyboardState();
41985 
41988  KeyboardState(KeyboardState const & in_that);
41989 
41993  KeyboardState(KeyboardState && in_that);
41994 
41998  KeyboardState & operator=(KeyboardState && in_that);
41999 
42000  ~KeyboardState();
42001 
42002  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
42003 
42006  void Assign(KeyboardState const & in_that);
42007 
42011  KeyboardState & operator=(KeyboardState const & in_that);
42012 
42016  bool Equals(KeyboardState const & in_that) const;
42017 
42021  bool operator== (KeyboardState const & in_that) const;
42022 
42026  bool operator!= (KeyboardState const & in_that) const;
42027 
42033  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
42034 
42037  HPS::KeyboardEvent GetActiveEvent() const;
42038 
42042  HPS::WindowKey GetEventSource() const;
42043 
42047  HPS::KeyArray GetEventPath() const;
42048 
42051  size_t GetKeyboardCodeCount() const;
42052 
42055  HPS::KeyboardCodeArray GetKeyboardCodes() const;
42056 
42060  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
42061 
42064  ModifierKeys GetModifierKeys() const;
42065 
42068  void SetActiveEvent(KeyboardEvent const & in_event);
42069 
42072  void SetEventPath(KeyArray const & in_path);
42073 
42076  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
42077 
42080  void SetModifierKeys(ModifierKeys in_modifiers);
42081 };
42082 
42083 
42087 
42090 class HPS_API IONotifier : public Object
42091 {
42092 public:
42094  IONotifier();
42095 
42098  IONotifier(IONotifier const & in_that);
42099 
42103  IONotifier(IONotifier && in_that);
42104 
42108  IONotifier & operator=(IONotifier && in_that);
42109 
42110  virtual ~IONotifier();
42111 
42112  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
42113 
42117  IONotifier & operator=(IONotifier const & in_that);
42118 
42121  void Assign(IONotifier const & in_that);
42122 
42124  void Wait();
42125 
42128  IOResult Status() const;
42129 
42133  IOResult Status(float & out_percent_complete) const;
42134 
42138  void Cancel();
42139 };
42140 
42142 class HPS_API Stream
42143 {
42144 public:
42146  class HPS_API Toolkit : public Object
42147  {
42148  public:
42150  Toolkit();
42151 
42154  Toolkit(Toolkit const & in_toolkit);
42155 
42159  Toolkit(Toolkit && in_toolkit);
42160 
42164  Toolkit & operator=(Toolkit const & in_toolkit);
42165 
42169  Toolkit & operator=(Toolkit && in_toolkit);
42170 
42171  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
42172 
42174  virtual void Restart();
42175  };
42176 
42179  static Toolkit CreateToolkit();
42180 
42182  class HPS_API ImportOptionsKit : public Object
42183  {
42184  public:
42186  ImportOptionsKit();
42187 
42190  ImportOptionsKit(ImportOptionsKit const & in_kit);
42191 
42195  ImportOptionsKit(ImportOptionsKit && in_that);
42196 
42200  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42201 
42202  virtual ~ImportOptionsKit();
42203 
42204  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
42205 
42208  void Set(ImportOptionsKit const & in_kit);
42209 
42212  void Show(ImportOptionsKit & out_kit) const;
42213 
42217  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42218 
42221  bool Empty() const;
42222 
42226  bool Equals(ImportOptionsKit const & in_kit) const;
42227 
42231  bool operator==(ImportOptionsKit const & in_kit) const;
42232 
42236  bool operator!=(ImportOptionsKit const & in_kit) const;
42237 
42240  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42241 
42244  ImportOptionsKit & UnsetToolkit();
42245 
42249  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42250 
42255  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42256 
42259  ImportOptionsKit & UnsetSegment();
42260 
42264  bool ShowSegment(SegmentKey & out_segment) const;
42265 
42270  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
42271 
42274  ImportOptionsKit & UnsetAlternateRoot();
42275 
42279  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42280 
42285  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42286 
42289  ImportOptionsKit & UnsetPortfolio();
42290 
42294  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42295 
42298  ImportOptionsKit & UnsetEverything();
42299  };
42300 
42302  class HPS_API ImportResultsKit : public Object
42303  {
42304  public:
42306  ImportResultsKit();
42307 
42310  ImportResultsKit(ImportResultsKit const & in_kit);
42311 
42315  ImportResultsKit(ImportResultsKit && in_that);
42316 
42320  ImportResultsKit & operator=(ImportResultsKit && in_that);
42321 
42322  virtual ~ImportResultsKit();
42323 
42324  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
42325 
42328  void Set(ImportResultsKit const & in_kit);
42329 
42332  void Show(ImportResultsKit & out_kit) const;
42333 
42337  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42338 
42341  bool Empty() const;
42342 
42346  bool Equals(ImportResultsKit const & in_kit) const;
42347 
42351  bool operator==(ImportResultsKit const & in_kit) const;
42352 
42356  bool operator!=(ImportResultsKit const & in_kit) const;
42357 
42362  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42363 
42367  ImportResultsKit & UnsetSegment();
42368 
42373  bool ShowSegment(SegmentKey & out_segment) const;
42374 
42379  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
42380 
42384  ImportResultsKit & UnsetAlternateRoot();
42385 
42391  bool ShowAlternateRoot(SegmentKey & out_segment) const;
42392 
42397  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42398 
42402  ImportResultsKit & UnsetPortfolio();
42403 
42409  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42410 
42415  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
42416 
42420  ImportResultsKit & UnsetDefaultCamera();
42421 
42425  bool ShowDefaultCamera(CameraKit & out_camera) const;
42426 
42427 
42433  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
42434 
42438  ImportResultsKit & UnsetAlternateCameras();
42439 
42444  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
42445 
42446 
42449  ImportResultsKit & UnsetEverything();
42450  };
42451 
42453  class HPS_API ExportOptionsKit : public Object
42454  {
42455  public:
42457  ExportOptionsKit();
42458 
42461  ExportOptionsKit(ExportOptionsKit const & in_kit);
42462 
42466  ExportOptionsKit(ExportOptionsKit && in_that);
42467 
42471  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42472 
42476  static ExportOptionsKit GetDefault();
42477 
42478  virtual ~ExportOptionsKit();
42479 
42480  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
42481 
42484  void Set(ExportOptionsKit const & in_kit);
42485 
42488  void Show(ExportOptionsKit & out_kit) const;
42489 
42493  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42494 
42497  bool Empty() const;
42498 
42502  bool Equals(ExportOptionsKit const & in_kit) const;
42503 
42507  bool operator==(ExportOptionsKit const & in_kit) const;
42508 
42512  bool operator!=(ExportOptionsKit const & in_kit) const;
42513 
42516  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
42517 
42525  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
42526 
42534  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
42535 
42541  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
42542 
42550  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
42551 
42559  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
42560 
42566  ExportOptionsKit & SetConnectivityCompression(bool in_state);
42567 
42573  ExportOptionsKit & SetSerializeTristrips(bool in_state);
42574 
42583  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
42584 
42587  ExportOptionsKit & UnsetToolkit();
42588 
42591  ExportOptionsKit & UnsetVertexCompression();
42592 
42595  ExportOptionsKit & UnsetNormalCompression();
42596 
42599  ExportOptionsKit & UnsetParameterCompression();
42600 
42603  ExportOptionsKit & UnsetColorCompression();
42604 
42607  ExportOptionsKit & UnsetIndexCompression();
42608 
42611  ExportOptionsKit & UnsetConnectivityCompression();
42612 
42615  ExportOptionsKit & UnsetImageCompression();
42616 
42619  ExportOptionsKit & UnsetSerializeTristrips();
42620 
42623  ExportOptionsKit & UnsetEverything();
42624 
42628  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
42629 
42634  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
42635 
42640  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
42641 
42646  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
42647 
42652  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
42653 
42658  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
42659 
42663  bool ShowConnectivityCompression(bool & out_state) const;
42664 
42669  bool ShowImageCompression(bool & out_state, float & out_quality) const;
42670 
42674  bool ShowSerializeTristrips(bool & out_state) const;
42675  };
42676 
42679  class HPS_API ImportNotifier : public IONotifier
42680  {
42681  public:
42683  ImportNotifier();
42684 
42687  ImportNotifier(ImportNotifier const & in_that);
42688 
42693  ImportNotifier(IONotifier const & in_that);
42694 
42698  ImportNotifier(ImportNotifier && in_that);
42699 
42703  ImportNotifier & operator=(ImportNotifier && in_that);
42704 
42705  virtual ~ImportNotifier();
42706 
42707  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
42708 
42712  ImportNotifier & operator=(ImportNotifier const & in_that);
42713 
42716  void Assign(ImportNotifier const & in_that);
42717 
42721  ImportResultsKit GetResults() const;
42722  };
42723 
42726  class HPS_API ExportNotifier : public IONotifier
42727  {
42728  public:
42730  ExportNotifier();
42731 
42734  ExportNotifier(ExportNotifier const & in_that);
42735 
42740  ExportNotifier(IONotifier const & in_that);
42741 
42745  ExportNotifier(ExportNotifier && in_that);
42746 
42750  ExportNotifier & operator=(ExportNotifier && in_that);
42751 
42752  virtual ~ExportNotifier();
42753 
42754  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
42755 
42759  ExportNotifier & operator=(ExportNotifier const & in_that);
42760 
42763  void Assign(ExportNotifier const & in_that);
42764  };
42765 
42766 
42768  class HPS_API File
42769  {
42770  public:
42776  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42777 
42784  static ExportNotifier Export(const char * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
42785 
42792  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
42793 
42794  private:
42796  File();
42797  };
42798 private:
42800  Stream();
42801 };
42802 
42806 
42811 class HPS_API Hardcopy
42812 {
42813 public:
42814 
42816  enum class SizeUnits
42817  {
42818  Centimeters,
42819  Inches,
42820  };
42821 
42823  enum class ResolutionUnits
42824  {
42825  DPCM,
42826  DPI,
42827  DotsPerCentimeter = DPCM,
42828  DotsPerInch = DPI,
42829  };
42830 
42832  class HPS_API File
42833  {
42834  public:
42835 
42837  class HPS_API ExportOptionsKit : public Object
42838  {
42839  public:
42841  ExportOptionsKit();
42842 
42845  ExportOptionsKit(ExportOptionsKit const & in_kit);
42846 
42850  ExportOptionsKit(ExportOptionsKit && in_that);
42851 
42855  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42856 
42857  virtual ~ExportOptionsKit();
42858 
42859  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
42860 
42863  void Set(ExportOptionsKit const & in_kit);
42864 
42867  void Show(ExportOptionsKit & out_kit) const;
42868 
42872  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42873 
42876  bool Empty() const;
42877 
42881  bool Equals(ExportOptionsKit const & in_kit) const;
42882 
42886  bool operator==(ExportOptionsKit const & in_kit) const;
42887 
42891  bool operator!=(ExportOptionsKit const & in_kit) const;
42892 
42893 
42894 
42895 
42901  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
42902 
42910  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
42911 
42914  ExportOptionsKit & UnsetSize();
42915 
42916 
42917 
42923  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
42924 
42931  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
42932 
42935  ExportOptionsKit & UnsetResolution();
42936 
42937 
42938 
42941  bool ShowWYSIWYG(bool & out_onoff) const;
42942 
42954  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
42955 
42958  ExportOptionsKit & UnsetWYSIWYG();
42959 
42960 
42963  ExportOptionsKit & UnsetEverything();
42964 
42965 
42969  static ExportOptionsKit GetDefault();
42970  };
42971 
42973  enum class Driver
42974  {
42975  PDF,
42976  Postscript
42977  };
42978 
42984  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
42985  private:
42986  File();
42987  };
42988 
42989 #ifdef _MSC_VER
42990  class HPS_API GDI
42991  {
42992  public:
42993 
42995  class HPS_API ExportOptionsKit : public Object
42996  {
42997  public:
42999  ExportOptionsKit();
43000 
43003  ExportOptionsKit(ExportOptionsKit const & in_kit);
43004 
43008  ExportOptionsKit(ExportOptionsKit && in_that);
43009 
43013  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43014 
43015  virtual ~ExportOptionsKit();
43016 
43017  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
43018 
43021  void Set(ExportOptionsKit const & in_kit);
43022 
43025  void Show(ExportOptionsKit & out_kit) const;
43026 
43030  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
43031 
43034  bool Empty() const;
43035 
43039  bool Equals(ExportOptionsKit const & in_kit) const;
43040 
43044  bool operator==(ExportOptionsKit const & in_kit) const;
43045 
43049  bool operator!=(ExportOptionsKit const & in_kit) const;
43050 
43051 
43052 
43053 
43057  bool ShowResolution(float & out_resolution) const;
43058 
43062  ExportOptionsKit & SetResolution(float in_resolution);
43063 
43066  ExportOptionsKit & UnsetResolution();
43067 
43068 
43069 
43070 
43073  bool ShowWYSIWYG(bool & out_onoff) const;
43074 
43078  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
43079 
43082  ExportOptionsKit & UnsetWYSIWYG();
43083 
43084 
43087  ExportOptionsKit & UnsetEverything();
43088  };
43089 
43096  static IOResult Export(intptr_t hdc, intptr_t attribdc, HPS::WindowKey const & window, ExportOptionsKit const & options);
43097 
43098  private:
43099  GDI();
43100  };
43101 #endif
43102 
43103 private:
43104  Hardcopy();
43105 };
43106 
43110 
43112 class HPS_API OBJ
43113 {
43114 public:
43115 
43117  class HPS_API ImportOptionsKit : public Object
43118  {
43119  public:
43121  ImportOptionsKit();
43122 
43125  ImportOptionsKit(ImportOptionsKit const & in_kit);
43126 
43130  ImportOptionsKit(ImportOptionsKit && in_that);
43131 
43135  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43136 
43137  virtual ~ImportOptionsKit();
43138 
43139  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
43140 
43143  void Set(ImportOptionsKit const & in_kit);
43144 
43147  void Show(ImportOptionsKit & out_kit) const;
43148 
43152  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43153 
43156  bool Empty() const;
43157 
43161  bool Equals(ImportOptionsKit const & in_kit) const;
43162 
43166  bool operator==(ImportOptionsKit const & in_kit) const;
43167 
43171  bool operator!=(ImportOptionsKit const & in_kit) const;
43172 
43177  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43178 
43181  ImportOptionsKit & UnsetSegment();
43182 
43186  bool ShowSegment(SegmentKey & out_segment) const;
43187 
43192  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43193 
43196  ImportOptionsKit & UnsetPortfolio();
43197 
43201  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43202 
43208  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43209 
43212  ImportOptionsKit & UnsetHandedness();
43213 
43217  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43218 
43221  ImportOptionsKit & UnsetEverything();
43222  };
43223 
43225  class HPS_API ImportResultsKit : public Object
43226  {
43227  public:
43229  ImportResultsKit();
43230 
43233  ImportResultsKit(ImportResultsKit const & in_kit);
43234 
43238  ImportResultsKit(ImportResultsKit && in_that);
43239 
43243  ImportResultsKit & operator=(ImportResultsKit && in_that);
43244 
43245  virtual ~ImportResultsKit();
43246 
43247  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
43248 
43251  void Set(ImportResultsKit const & in_kit);
43252 
43255  void Show(ImportResultsKit & out_kit) const;
43256 
43260  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43261 
43264  bool Empty() const;
43265 
43269  bool Equals(ImportResultsKit const & in_kit) const;
43270 
43274  bool operator==(ImportResultsKit const & in_kit) const;
43275 
43279  bool operator!=(ImportResultsKit const & in_kit) const;
43280 
43285  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43286 
43290  ImportResultsKit & UnsetSegment();
43291 
43296  bool ShowSegment(SegmentKey & out_segment) const;
43297 
43302  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
43303 
43307  ImportResultsKit & UnsetPortfolio();
43308 
43314  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
43315 
43320  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
43321 
43325  ImportResultsKit & UnsetHandedness();
43326 
43331  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
43332 
43335  ImportResultsKit & UnsetEverything();
43336  };
43337 
43340  class HPS_API ImportNotifier : public IONotifier
43341  {
43342  public:
43344  ImportNotifier();
43345 
43348  ImportNotifier(ImportNotifier const & in_that);
43349 
43354  ImportNotifier(IONotifier const & in_that);
43355 
43359  ImportNotifier(ImportNotifier && in_that);
43360 
43364  ImportNotifier & operator=(ImportNotifier && in_that);
43365 
43366  virtual ~ImportNotifier();
43367 
43368  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
43369 
43373  ImportNotifier & operator=(ImportNotifier const & in_that);
43374 
43377  void Assign(ImportNotifier const & in_that);
43378 
43382  ImportResultsKit GetResults() const;
43383  };
43384 
43385 
43387  class HPS_API File
43388  {
43389  public:
43395  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43396 
43397  private:
43399  File();
43400  };
43401 private:
43403  OBJ();
43404 };
43405 
43409 
43411 class HPS_API STL
43412 {
43413 public:
43414 
43416  class HPS_API ImportOptionsKit : public Object
43417  {
43418  public:
43420  ImportOptionsKit();
43421 
43424  ImportOptionsKit(ImportOptionsKit const & in_kit);
43425 
43429  ImportOptionsKit(ImportOptionsKit && in_that);
43430 
43434  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43435 
43436  virtual ~ImportOptionsKit();
43437 
43438  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
43439 
43442  void Set(ImportOptionsKit const & in_kit);
43443 
43446  void Show(ImportOptionsKit & out_kit) const;
43447 
43451  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43452 
43455  bool Empty() const;
43456 
43460  bool Equals(ImportOptionsKit const & in_kit) const;
43461 
43465  bool operator==(ImportOptionsKit const & in_kit) const;
43466 
43470  bool operator!=(ImportOptionsKit const & in_kit) const;
43471 
43475  static ImportOptionsKit GetDefault();
43476 
43481  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
43482 
43490  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
43491 
43498  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
43499 
43500 
43503  ImportOptionsKit & UnsetSegment();
43504 
43507  ImportOptionsKit & UnsetOptimization();
43508 
43511  ImportOptionsKit & UnsetEverything();
43512 
43513 
43517  bool ShowSegment(SegmentKey & out_segment) const;
43518 
43523  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
43524  };
43525 
43527  class HPS_API ImportResultsKit : public Object
43528  {
43529  public:
43531  ImportResultsKit();
43532 
43535  ImportResultsKit(ImportResultsKit const & in_kit);
43536 
43540  ImportResultsKit(ImportResultsKit && in_that);
43541 
43545  ImportResultsKit & operator=(ImportResultsKit && in_that);
43546 
43547  virtual ~ImportResultsKit();
43548 
43549  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
43550 
43553  void Set(ImportResultsKit const & in_kit);
43554 
43557  void Show(ImportResultsKit & out_kit) const;
43558 
43562  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
43563 
43566  bool Empty() const;
43567 
43571  bool Equals(ImportResultsKit const & in_kit) const;
43572 
43576  bool operator==(ImportResultsKit const & in_kit) const;
43577 
43581  bool operator!=(ImportResultsKit const & in_kit) const;
43582 
43587  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
43588 
43592  ImportResultsKit & UnsetSegment();
43593 
43598  bool ShowSegment(SegmentKey & out_segment) const;
43599 
43602  ImportResultsKit & UnsetEverything();
43603  };
43604 
43607  class HPS_API ImportNotifier : public IONotifier
43608  {
43609  public:
43611  ImportNotifier();
43612 
43615  ImportNotifier(ImportNotifier const & in_that);
43616 
43621  ImportNotifier(IONotifier const & in_that);
43622 
43626  ImportNotifier(ImportNotifier && in_that);
43627 
43631  ImportNotifier & operator=(ImportNotifier && in_that);
43632 
43633  virtual ~ImportNotifier();
43634 
43635  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
43636 
43640  ImportNotifier & operator=(ImportNotifier const & in_that);
43641 
43644  void Assign(ImportNotifier const & in_that);
43645 
43649  ImportResultsKit GetResults() const;
43650  };
43651 
43652 
43654  class HPS_API File
43655  {
43656  public:
43662  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
43663 
43664  private:
43666  File();
43667  };
43668 private:
43670  STL();
43671 };
43672 
43673 }
43674 
43675 #ifdef _MSC_VER
43676 # pragma warning(pop)
43677 #endif
43678 
43679 #endif
43680 
43681 
HPS::Type ObjectType() const
Definition: hps.h:39893
Rotation
Definition: hps.h:1588
HPS::Type ObjectType() const
Definition: hps.h:26861
bool Empty() const
Definition: hps.h:6822
CameraPoint(Point const &in_point)
Definition: hps.h:5773
Alignment
Definition: hps.h:1521
HPS::Type ObjectType() const
Definition: hps.h:19246
Space
Definition: hps.h:554
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41643
Definition: hps.h:3252
Definition: hps.h:6012
Channel
Definition: hps.h:938
HPS::Type ObjectType() const
Definition: hps.h:24031
Handedness
Definition: hps.h:1269
Definition: hps.h:14112
Definition: hps.h:1044
Definition: hps.h:11895
ColorSource
Definition: hps.h:1914
HPS::Type ObjectType() const
Definition: hps.h:16983
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:41429
HPS::Type ObjectType() const
Definition: hps.h:36195
Event(intptr_t in_channel=0)
Definition: hps.h:6126
Definition: hps.h:18098
HPS::Type ObjectType() const
Definition: hps.h:43368
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3744
float alpha
Definition: hps.h:4283
Definition: hps.h:34600
HPS::Type ObjectType() const
Definition: hps.h:35802
bool operator==(Touch const &in_that) const
Definition: hps.h:6416
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:41450
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41084
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40840
InformationEvent(char const *in_message)
Definition: hps.h:40640
HPS::Type ObjectType() const
Definition: hps.h:38238
HPS::Type ObjectType() const
Definition: hps.h:34266
HPS::Type ObjectType() const
Definition: hps.h:21761
HPS::Type ObjectType() const
Definition: hps.h:23559
HPS::Type ObjectType() const
Definition: hps.h:24305
Action
Definition: hps.h:41226
Orientation
Definition: hps.h:530
Definition: hps.h:20577
Code
Definition: hps.h:127
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1324
Multiline strings will be left justfied.
Definition: hps.h:39710
HPS::Type ObjectType() const
Definition: hps.h:14866
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40895
HPS::Type ObjectType() const
Definition: hps.h:8608
HPS::Type ObjectType() const
Definition: hps.h:28089
Event * Clone() const
Definition: hps.h:40738
Definition: hps.h:13171
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41560
Definition: hps.h:43112
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40526
ImportStatusEvent()
Definition: hps.h:40983
HPS::Type ObjectType() const
Definition: hps.h:21378
HPS::Type ObjectType() const
Definition: hps.h:35977
Definition: hps.h:13678
HPS::Type ObjectType() const
Definition: hps.h:25824
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41291
HPS::Type ObjectType() const
Definition: hps.h:30129
HPS::Type ObjectType() const
Definition: hps.h:25435
HPS::Type ObjectType() const
Definition: hps.h:11546
static MouseButtons ButtonX2()
Definition: hps.h:41505
Definition: hps.h:19680
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40787
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41749
Definition: hps.h:43527
Definition: hps.h:37869
Definition: hps.h:19040
HPS::Type ObjectType() const
Definition: hps.h:37689
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5670
Definition: hps.h:1487
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5918
bool Middle() const
Definition: hps.h:41415
Definition: hps.h:460
Driver
Definition: hps.h:147
HPS::Type ObjectType() const
Definition: hps.h:41789
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2185
Definition: hps.h:35299
HPS::Type ObjectType() const
Definition: hps.h:39037
CappingLevel
Definition: hps.h:1720
Definition: hps.h:41651
HPS::Type ObjectType() const
Definition: hps.h:23286
HPS::Type ObjectType() const
Definition: hps.h:35730
Definition: hps.h:9298
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12684
HPS::Type ObjectType() const
Definition: hps.h:41901
HPS::Type ObjectType() const
Definition: hps.h:20422
Definition: hps.h:26448
HPS::Type ObjectType() const
Definition: hps.h:13701
InputEvent()
Definition: hps.h:41169
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5530
static MouseButtons ButtonRight()
Definition: hps.h:41493
HPS::Type ObjectType() const
Definition: hps.h:28874
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3851
Definition: hps.h:5570
Definition: hps.h:35565
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41688
static ModifierKeys KeyMeta()
Definition: hps.h:41143
HPS::Type ObjectType() const
Definition: hps.h:35465
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1498
Definition: hps.h:23452
HPS::Type ObjectType() const
Definition: hps.h:36844
Definition: hps.h:16579
HPS::Type ObjectType() const
Definition: hps.h:42754
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:41380
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3730
Definition: hps.h:34957
HPS::Type ObjectType() const
Definition: hps.h:19485
HPS::Type ObjectType() const
Definition: hps.h:39209
HPS::Type ObjectType() const
Definition: hps.h:23484
HPS::Type ObjectType() const
Definition: hps.h:35036
Definition: hps.h:22309
HPS::Type ObjectType() const
Definition: hps.h:16692
MouseButtons()
Definition: hps.h:41375
HPS::Type ObjectType() const
Definition: hps.h:38278
Definition: hps.h:20190
Time GetTimeStamp() const
Definition: hps.h:6148
Definition: hps.h:43654
void Left(bool in_state)
Definition: hps.h:41438
HPS::Type ObjectType() const
Definition: hps.h:22279
NormalizedPoint(Point const &in_point)
Definition: hps.h:5823
HPS::Type ObjectType() const
Definition: hps.h:23833
Event * Clone() const
Definition: hps.h:40555
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3779
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:41434
Renderer
Definition: hps.h:1569
HPS::Type ObjectType() const
Definition: hps.h:34002
Definition: hps.h:40046
KeyboardEvent()
Definition: hps.h:41664
HPS::Type ObjectType() const
Definition: hps.h:7335
Definition: hps.h:37656
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3972
ObjectPoint(Point const &in_point)
Definition: hps.h:5673
HPS::Type ObjectType() const
Definition: hps.h:17570
Definition: hps.h:33452
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:39813
Definition: hps.h:4360
Definition: hps.h:6631
Definition: hps.h:1318
Definition: hps.h:40576
Definition: hps.h:24273
Point_3D< F > min
Definition: hps.h:3714
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40869
static ModifierKeys KeyAlt()
Definition: hps.h:41139
bool IsConsumable() const
Definition: hps.h:6151
Definition: hps.h:1041
size_t GetHash() const
Definition: hps.h:1659
MaterialPreference
Definition: hps.h:1737
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41677
Mobility
Definition: hps.h:187
HPS::Type ObjectType() const
Definition: hps.h:13194
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5871
Definition: hps.h:14549
InterpolationAlgorithm
Definition: hps.h:1504
Fill
Definition: hps.h:1905
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3767
Definition: hps.h:23727
Definition: hps.h:19223
HPS::Type ObjectType() const
Definition: hps.h:27366
HPS::Type ObjectType() const
Definition: hps.h:19063
char At(size_t in_index) const
Definition: hps.h:6865
Definition: hps.h:39882
Definition: hps.h:4386
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41079
HPS::Type ObjectType() const
Definition: hps.h:35857
Definition: hps.h:122
ReferenceFrame
Definition: hps.h:1536
Definition: hps.h:25792
Bloom Shape.
Definition: hps.h:41980
Definition: hps.h:3712
Definition: hps.h:3709
HPS::Type ObjectType() const
Definition: hps.h:16899
GreekingUnits
Definition: hps.h:1623
Definition: hps.h:18590
Definition: hps.h:7387
HPS::Type ObjectType() const
Definition: hps.h:12096
InnerConeUnits
Definition: hps.h:479
Definition: hps.h:26658
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5967
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3884
static MouseButtons ButtonX1()
Definition: hps.h:41501
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40945
Definition: hps.h:18309
Definition: hps.h:3399
OuterConeUnits
Definition: hps.h:465
Definition: hps.h:6398
void X2(bool in_state)
Definition: hps.h:41454
HPS::Type ObjectType() const
Definition: hps.h:18847
HPS::Type ObjectType() const
Definition: hps.h:40376
HPS::Type ObjectType() const
Definition: hps.h:39306
HPS::Type ObjectType() const
Definition: hps.h:14297
Definition: hps.h:14842
Definition: hps.h:1986
HPS::Type ObjectType() const
Definition: hps.h:33485
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41756
HPS::Type ObjectType() const
Definition: hps.h:26760
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41315
HPS::Type ObjectType() const
Definition: hps.h:12567
HPS::Type ObjectType() const
Definition: hps.h:25017
Definition: hps.h:434
HPS::Type ObjectType() const
Definition: hps.h:36308
Definition: hps.h:21739
Channel
Definition: hps.h:897
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40769
AreaUnits
Definition: hps.h:1450
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3821
Definition: hps.h:38058
HPS::Type ObjectType() const
Definition: hps.h:11919
Definition: hps.h:8559
Definition: hps.h:26738
Definition: hps.h:19462
HPS::Type ObjectType() const
Definition: hps.h:34622
Action
Definition: hps.h:40851
Event * Clone() const
Definition: hps.h:40667
HPS::Type ObjectType() const
Definition: hps.h:14135
Definition: hps.h:4635
HPS::Type ObjectType() const
Definition: hps.h:42480
HPS::Type ObjectType() const
Definition: hps.h:27467
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6431
Definition: hps.h:21168
Definition: hps.h:4517
HPS::Type ObjectType() const
Definition: hps.h:37807
HPS::Type ObjectType() const
Definition: hps.h:34139
Definition: hps.h:1377
Definition: hps.h:17780
Definition: hps.h:872
Definition: hps.h:5556
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41248
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3930
Border
Definition: hps.h:257
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41074
Definition: hps.h:37774
Definition: hps.h:35955
Definition: hps.h:7377
HPS::Type ObjectType() const
Definition: hps.h:23036
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41725
HPS::Type ObjectType() const
Definition: hps.h:21303
WarningEvent(Event const &in_event)
Definition: hps.h:40720
Definition: hps.h:36867
HPS::Type ObjectType() const
Definition: hps.h:11422
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1924
Definition: hps.h:1705
static ModifierKeys KeyShift()
Definition: hps.h:41131
Definition: hps.h:142
HPS::Type ObjectType() const
Definition: hps.h:28600
Shape
Definition: hps.h:1066
bool IsValid() const
Definition: hps.h:6815
Definition: hps.h:20399
Definition: hps.h:1516
Cuboid_3D()
Definition: hps.h:3722
ErrorEvent(Event const &in_event)
Definition: hps.h:40791
size_t GetWStrLength() const
Definition: hps.h:6844
Event * Clone() const
Definition: hps.h:40620
HPS::Type ObjectType() const
Definition: hps.h:11013
AppendMode
Definition: hps.h:325
Definition: hps.h:8588
Definition: hps.h:25265
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:41419
Definition: hps.h:229
Definition: hps.h:40979
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3915
void Meta(bool in_state)
Definition: hps.h:41096
Definition: hps.h:6583
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6066
Definition: hps.h:26839
HPS::Type ObjectType() const
Definition: hps.h:14575
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3772
HPS::Type ObjectType() const
Definition: hps.h:38390
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40916
Definition: hps.h:20968
Quality
Definition: hps.h:1050
ResolutionUnits
Definition: hps.h:42823
Event * Clone() const
Definition: hps.h:41179
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:41217
Definition: hps.h:4459
TimerTickEvent(Event const &in_event)
Definition: hps.h:40545
Component
Definition: hps.h:345
Definition: hps.h:43225
Definition: hps.h:5665
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6017
HPS::Type ObjectType() const
Definition: hps.h:12183
Definition: hps.h:12309
Default
Definition: hps.h:1878
HPS::Type ObjectType() const
Definition: hps.h:10643
Definition: hps.h:16876
Definition: hps.h:2125
Definition: hps.h:24723
InformationEvent()
Definition: hps.h:40636
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5057
Definition: hps.h:37608
Definition: hps.h:11522
Definition: hps.h:13758
Definition: hps.h:10989
Definition: hps.h:43607
bool Shift() const
Definition: hps.h:41056
SizeToleranceUnits
Definition: hps.h:1610
HPS::Type ObjectType() const
Definition: hps.h:38514
Definition: hps.h:1757
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4001
Cap
Definition: hps.h:1829
Point_3D< F > max
Definition: hps.h:3716
HPS::Type ObjectType() const
Definition: hps.h:7415
Definition: hps.h:11255
Definition: hps.h:20745
Definition: hps.h:13864
HPS::Type ObjectType() const
Definition: hps.h:43139
HPS::Type ObjectType() const
Definition: hps.h:43247
MouseEvent()
Definition: hps.h:41542
Definition: hps.h:13935
HPS::Type ObjectType() const
Definition: hps.h:12024
Definition: hps.h:19952
Definition: hps.h:27110
Definition: hps.h:1060
HPS::Type ObjectType() const
Definition: hps.h:16601
Definition: hps.h:12217
Definition: hps.h:32259
HPS::Type ObjectType() const
Definition: hps.h:35081
Definition: hps.h:12543
static const float Infinity
Definition: hps.h:2180
InsetBehavior
Definition: hps.h:1810
HPS::Type ObjectType() const
Definition: hps.h:24943
Definition: hps.h:5639
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2193
HPS::Type ObjectType() const
Definition: hps.h:13589
HPS::Type ObjectType() const
Definition: hps.h:27060
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6430
HPS::Type ObjectType() const
Definition: hps.h:35271
HPS::Type ObjectType() const
Definition: hps.h:37534
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3894
Algorithm
Definition: hps.h:1438
Definition: hps.h:41879
Decimation
Definition: hps.h:1007
StaticModel
Definition: hps.h:1108
Definition: hps.h:38490
Granularity
Definition: hps.h:1359
Parameterization
Definition: hps.h:37921
Definition: hps.h:36765
DisplayLists
Definition: hps.h:1086
Definition: hps.h:10821
Search the current segment only.
Definition: hps.h:42726
Definition: hps.h:2639
Definition: hps.h:42453
Definition: hps.h:549
KeyboardEvent(Event const &in_event)
Definition: hps.h:41697
Definition: hps.h:21019
Definition: hps.h:35008
ClipOperation
Definition: hps.h:1298
HPS::Type ObjectType() const
Definition: hps.h:8860
Definition: hps.h:2552
Definition: hps.h:30096
Method
Definition: hps.h:1428
Definition: hps.h:36811
HPS::Type ObjectType() const
Definition: hps.h:26480
Definition: hps.h:42768
Parameterization
Definition: hps.h:952
Definition: hps.h:4277
Definition: hps.h:37062
Definition: hps.h:36281
FocusLostEvent()
Definition: hps.h:40924
CuttingLevel
Definition: hps.h:1729
Channel
Definition: hps.h:918
Definition: hps.h:9379
Definition: hps.h:43416
HandleResult
Definition: hps.h:40516
Definition: hps.h:39015
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5069
Definition: hps.h:5913
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40839
Value
Definition: hps.h:1409
Definition: hps.h:1080
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2201
Code
Definition: hps.h:99
HPS::Type ObjectType() const
Definition: hps.h:25976
Event * Clone() const
Definition: hps.h:40932
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41596
Definition: hps.h:42146
Definition: hps.h:41525
ErrorEvent()
Definition: hps.h:40778
Definition: hps.h:40845
Justification
Definition: hps.h:1544
The vertex colors applied to faces.
Definition: hps.h:6503
HPS::Type ObjectType() const
Definition: hps.h:13959
Definition: hps.h:35137
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5548
ErrorEvent(char const *in_message)
Definition: hps.h:40782
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:40952
Definition: hps.h:41221
FrameSize
Definition: hps.h:198
Definition: hps.h:2140
Definition: hps.h:9189
Definition: hps.h:23537
Definition: hps.h:12001
Justification
Definition: hps.h:1846
Definition: hps.h:21496
HPS::Type ObjectType() const
Definition: hps.h:11744
Definition: hps.h:40353
Definition: hps.h:37817
HPS::Type ObjectType() const
Definition: hps.h:19704
Definition: hps.h:1683
Definition: hps.h:1464
HPS::Type ObjectType() const
Definition: hps.h:22110
bool None() const
Definition: hps.h:41403
Definition: hps.h:309
Definition: hps.h:1403
HPS::Type ObjectType() const
Definition: hps.h:8655
HPS::Type ObjectType() const
Definition: hps.h:36798
HPS::Type ObjectType() const
Definition: hps.h:34985
Definition: hps.h:17547
GreekingMode
Definition: hps.h:1635
HPS::Type ObjectType() const
Definition: hps.h:20214
Definition: hps.h:36173
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41761
Operation
Definition: hps.h:448
Definition: hps.h:1422
HPS::Type ObjectType() const
Definition: hps.h:37379
Type
Definition: hps.h:1992
WorldPoint(Point const &in_point)
Definition: hps.h:5723
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41355
Definition: hps.h:43387
HPS::Type ObjectType() const
Definition: hps.h:9842
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2472
Definition: hps.h:22509
HPS::Type ObjectType() const
Definition: hps.h:6662
Definition: hps.h:34751
Definition: hps.h:17852
TouchEvent(Event const &in_event)
Definition: hps.h:41263
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41349
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6947
Definition: hps.h:5040
Definition: hps.h:39283
Definition: hps.h:43411
Definition: hps.h:35238
Definition: hps.h:4216
Relation
Definition: hps.h:371
Action
Definition: hps.h:41656
ChannelMapping
Definition: hps.h:1021
HPS::Type ObjectType() const
Definition: hps.h:22628
Definition: hps.h:6760
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5565
HPS::Type ObjectType() const
Definition: hps.h:38856
HPS::Type ObjectType() const
Definition: hps.h:39495
Definition: hps.h:23811
Definition: hps.h:5766
HPS::Type ObjectType() const
Definition: hps.h:42171
bool Alt() const
Definition: hps.h:41064
Definition: hps.h:41371
ToleranceUnits
Definition: hps.h:354
Definition: hps.h:24590
Definition: hps.h:27334
Definition: hps.h:37916
HPS::Type ObjectType() const
Definition: hps.h:12494
SizeUnits
Definition: hps.h:1797
Type
Definition: hps.h:2009
HPS::Type ObjectType() const
Definition: hps.h:17699
The vertex colors applied to faces.
RelationTest
Definition: hps.h:381
Definition: hps.h:39187
Type
Definition: hps.h:316
HPS::Type ObjectType() const
Definition: hps.h:14719
Behavior
Definition: hps.h:563
Definition: hps.h:5716
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6737
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41762
Definition: hps.h:40532
HPS::Type ObjectType() const
Definition: hps.h:18613
Style Append Mode.
ImageFormat
Definition: hps.h:213
Definition: hps.h:38539
Definition: hps.h:25413
Definition: hps.h:41767
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5539
float blue
Definition: hps.h:4282
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:40920
Type
Definition: hps.h:421
HPS::Type ObjectType() const
Definition: hps.h:21042
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6965
PixelPoint(Point const &in_point)
Definition: hps.h:6069
HPS::Type ObjectType() const
Definition: hps.h:6191
HPS::Type ObjectType() const
Definition: hps.h:7054
Definition: hps.h:17675
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41622
Definition: hps.h:20881
Definition: hps.h:42679
HPS::Type ObjectType() const
Definition: hps.h:21639
HPS::Type ObjectType() const
Definition: hps.h:21519
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35224
HPS::Type ObjectType() const
Definition: hps.h:28743
HPS::Type ObjectType() const
Definition: hps.h:24104
HPS::Type ObjectType() const
Definition: hps.h:39135
HPS::Type ObjectType() const
Definition: hps.h:20904
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41642
Event * Clone() const
Definition: hps.h:41010
Definition: hps.h:14259
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5063
Definition: hps.h:35824
Definition: hps.h:40941
HPS::Type ObjectType() const
Definition: hps.h:34536
HPS::Type ObjectType() const
Definition: hps.h:40485
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:42302
HPS::Type ObjectType() const
Definition: hps.h:15750
Definition: hps.h:1900
Definition: hps.h:31193
Infinite line which extends infinitely in both directions along a vector.
InformationEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40645
intptr_t GetChannel() const
Definition: hps.h:6145
HPS::Type ObjectType() const
Definition: hps.h:9213
Definition: hps.h:1337
Definition: hps.h:13565
Algorithm
Definition: hps.h:1351
HPS::Type ObjectType() const
Definition: hps.h:31215
HPS::Type ObjectType() const
Definition: hps.h:37850
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3839
Definition: hps.h:12471
Definition: hps.h:10619
Driver
Definition: hps.h:42973
Definition: hps.h:7006
Definition: hps.h:42090
SizeUnits
Definition: hps.h:1665
StandAloneWindowEvent()
Definition: hps.h:40860
HPS::Type ObjectType() const
Definition: hps.h:36377
HPS::Type ObjectType() const
Definition: hps.h:34374
ModifierKeys GetModifierKeys() const
Definition: hps.h:41212
Definition: hps.h:41020
Definition: hps.h:39464
Definition: hps.h:40703
HPS::Type ObjectType() const
Definition: hps.h:12332
HPS::Type ObjectType() const
Definition: hps.h:11163
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40747
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41550
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5511
HPS::Type ObjectType() const
Definition: hps.h:17410
Definition: hps.h:38205
Level
Definition: hps.h:1342
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:40676
bool X2() const
Definition: hps.h:41423
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41029
Definition: hps.h:34352
Definition: hps.h:43340
bool Left() const
Definition: hps.h:41407
void Control(bool in_state)
Definition: hps.h:41088
Definition: hps.h:21607
Definition: hps.h:2889
Definition: hps.h:16959
Definition: hps.h:41164
HPS::Type ObjectType() const
Definition: hps.h:42707
HPS::Type ObjectType() const
Definition: hps.h:18121
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3986
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40768
The base class of all HPS exceptions.
Definition: hps.h:5503
RegionAlignment
Definition: hps.h:1644
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41257
Event * Clone() const
Definition: hps.h:41587
Definition: hps.h:6112
HPS::Type ObjectType() const
Definition: hps.h:21191
Definition: hps.h:37306
InformationEvent(Event const &in_event)
Definition: hps.h:40649
Definition: hps.h:12746
void Invalidate()
Definition: hps.h:3784
Definition: hps.h:23004
Definition: hps.h:38833
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4778
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5562
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40948
HPS::Type ObjectType() const
Definition: hps.h:33862
Definition: hps.h:6062
HPS::Type ObjectType() const
Definition: hps.h:39732
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6138
Definition: hps.h:396
char const * GetBytes() const
Definition: hps.h:6851
Definition: hps.h:38080
virtual intptr_t Freshen() const
Definition: hps.h:41634
Definition: hps.h:34233
HPS::Type ObjectType() const
Definition: hps.h:35333
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:41173
float green
Definition: hps.h:4281
Action
Definition: hps.h:41531
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1689
HPS::Type ObjectType() const
Definition: hps.h:10247
HPS::Type ObjectType() const
Definition: hps.h:27132
HPS::Type ObjectType() const
Definition: hps.h:24622
HPS::Type ObjectType() const
Definition: hps.h:24378
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10446
HPS::Type ObjectType() const
Definition: hps.h:37902
HPS::Type ObjectType() const
Definition: hps.h:24745
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5970
ImportStatusEvent(Event const &in_event)
Definition: hps.h:40995
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5820
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6410
static const float NegativeInfinity
Definition: hps.h:2182
HighlightEvent(Event const &in_event)
Definition: hps.h:40603
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6956
SizeUnits
Definition: hps.h:1470
HPS::Type ObjectType() const
Definition: hps.h:12770
HPS::Type ObjectType() const
Definition: hps.h:20600
Definition: hps.h:21280
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41644
HPS::Type ObjectType() const
Definition: hps.h:10468
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5921
GatheringLevel
Definition: hps.h:1745
HPS::Type ObjectType() const
Definition: hps.h:28953
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:40698
Definition: hps.h:40458
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3751
Definition: hps.h:12366
FrameOptions
Definition: hps.h:207
HPS::Type ObjectType() const
Definition: hps.h:35174
Space
Definition: hps.h:8566
void Alt(bool in_state)
Definition: hps.h:41092
Definition: hps.h:7015
Buttons
Definition: hps.h:41511
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41669
HPS::Type ObjectType() const
Definition: hps.h:37106
Type
Definition: hps.h:251
bool operator!=(Touch const &in_that) const
Definition: hps.h:6424
Definition: hps.h:40074
Definition: hps.h:23999
Definition: hps.h:94
Type
Definition: hps.h:439
HPS::Type ObjectType() const
Definition: hps.h:42204
HPS::Type ObjectType() const
Definition: hps.h:43549
HPS::Type ObjectType() const
Definition: hps.h:38102
HPS::Type ObjectType() const
Definition: hps.h:43438
HPS::Type ObjectType() const
Definition: hps.h:33593
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5720
HPS::Type ObjectType() const
Definition: hps.h:9403
HPS::Type ObjectType() const
Definition: hps.h:43635
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6938
Definition: hps.h:23264
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41342
Definition: hps.h:35059
Definition: hps.h:1264
Event * Clone() const
Definition: hps.h:41282
void Middle(bool in_state)
Definition: hps.h:41446
Definition: hps.h:28931
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40818
Definition: hps.h:4786
Event * Clone() const
Definition: hps.h:40886
size_t GetLength() const
Definition: hps.h:6836
HPS::Type ObjectType() const
Definition: hps.h:20991
HPS::Type ObjectType() const
Definition: hps.h:26690
Type
Definition: hps.h:1127
Definition: hps.h:416
HPS::Type ObjectType() const
Definition: hps.h:9321
bool None() const
Definition: hps.h:41052
size_t ClickCount
The number of clicks received.
Definition: hps.h:41646
virtual intptr_t Freshen() const
Definition: hps.h:6142
void Reset()
Definition: hps.h:6831
HPS::Type ObjectType() const
Definition: hps.h:37636
HPS::Type ObjectType() const
Definition: hps.h:23759
Definition: hps.h:34106
HPS::Type ObjectType() const
Definition: hps.h:39836
Definition: hps.h:39112
SizeUnits
Definition: hps.h:1598
Event * Clone() const
Definition: hps.h:40809
MouseEvent(Event const &in_event)
Definition: hps.h:41565
bool Right() const
Definition: hps.h:41411
Definition: hps.h:2004
virtual bool Empty() const
Definition: hps.h:5603
Join
Definition: hps.h:1820
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3908
Modifier
Definition: hps.h:1857
static MouseButtons ButtonLeft()
Definition: hps.h:41489
static MouseButtons ButtonMiddle()
Definition: hps.h:41497
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41240
HighlightEvent()
Definition: hps.h:40587
virtual HPS::Type ObjectType() const
Definition: hps.h:5599
Definition: hps.h:18823
HPS::Type ObjectType() const
Definition: hps.h:13782
Definition: hps.h:28583
Definition: hps.h:16670
Definition: hps.h:5815
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41354
Definition: hps.h:8626
Type
Definition: hps.h:574
virtual intptr_t Freshen() const
Definition: hps.h:40570
Background
Definition: hps.h:232
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3828
Definition: hps.h:42832
static ModifierKeys KeyControl()
Definition: hps.h:41135
HPS::Type ObjectType() const
Definition: hps.h:18333
Definition: hps.h:5521
HPS::Type ObjectType() const
Definition: hps.h:35587
Definition: hps.h:7309
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5868
HPS::Type ObjectType() const
Definition: hps.h:39628
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40865
Mode
Definition: hps.h:1710
Definition: hps.h:33232
Definition: hps.h:11140
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:40697
Event * Clone() const
Definition: hps.h:40969
Definition: hps.h:33968
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4045
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3863
Definition: hps.h:33830
Type
Definition: hps.h:877
Definition: hps.h:339
Definition: hps.h:14696
Definition: hps.h:21355
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3816
Definition: hps.h:912
HPS::Type ObjectType() const
Definition: hps.h:12241
Definition: hps.h:35769
HPS::Type ObjectType() const
Definition: hps.h:32292
HPS::Type ObjectType() const
Definition: hps.h:17803
Definition: hps.h:42142
HPS::Type ObjectType() const
Definition: hps.h:37734
Definition: hps.h:35443
HPS::Type ObjectType() const
Definition: hps.h:42324
Definition: hps.h:5864
Definition: hps.h:37948
HPS::Type ObjectType() const
Definition: hps.h:42002
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3802
HPS::Type ObjectType() const
Definition: hps.h:36889
Definition: hps.h:35708
HPS::Type ObjectType() const
Definition: hps.h:12390
HPS::Type ObjectType() const
Definition: hps.h:17876
Definition: hps.h:24082
Mode
Definition: hps.h:1763
Definition: hps.h:8828
Event * Clone() const
Definition: hps.h:41716
Definition: hps.h:10223
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3874
Tiling
Definition: hps.h:980
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4030
WindowPoint(Point const &in_point)
Definition: hps.h:6020
Transform
Definition: hps.h:1553
HPS::Type ObjectType() const
Definition: hps.h:37204
Definition: hps.h:11399
Definition: hps.h:40632
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:21962
Definition: hps.h:35192
Definition: hps.h:27445
Definition: hps.h:22247
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:38561
Definition: hps.h:25954
Definition: hps.h:932
ModifierKeys()
Definition: hps.h:41024
Definition: hps.h:24995
Definition: hps.h:1792
Definition: hps.h:22606
Definition: hps.h:28057
Preference
Definition: hps.h:1578
HPS::Type ObjectType() const
Definition: hps.h:25297
Capping
Definition: hps.h:519
Definition: hps.h:40774
HPS::Type ObjectType() const
Definition: hps.h:35405
TouchEvent()
Definition: hps.h:41234
Interpolation
Definition: hps.h:996
HPS::Type ObjectType() const
Definition: hps.h:19975
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:41188
WarningEvent(char const *in_message)
Definition: hps.h:40711
HPS::Type ObjectType() const
Definition: hps.h:20768
Modifiers
Definition: hps.h:41149
Component
Definition: hps.h:511
Definition: hps.h:506
Definition: hps.h:9819
Definition: hps.h:37510
HPS::Type ObjectType() const
Definition: hps.h:35895
HPS::Type ObjectType() const
Definition: hps.h:6527
HPS::Type ObjectType() const
Definition: hps.h:22541
Definition: hps.h:17386
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4015
HPS::Type ObjectType() const
Definition: hps.h:42859
HPS::Type ObjectType() const
Definition: hps.h:22331
Definition: hps.h:3175
Format
Definition: hps.h:37067
WarningEvent()
Definition: hps.h:40707
Definition: hps.h:24911
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40564
Touch()
Definition: hps.h:6404
Definition: hps.h:12160
Definition: hps.h:35862
Component
Definition: hps.h:401
Definition: hps.h:33577
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:39605
Definition: hps.h:1122
float red
Definition: hps.h:4280
ClipSpace
Definition: hps.h:1306
Definition: hps.h:12072
Definition: hps.h:37701
Definition: hps.h:15727
Control & operator=(Control &&in_that)
Definition: hps.h:5656
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40716
HPS::Type ObjectType() const
Definition: hps.h:13887
Definition: hps.h:28852
SizeUnits
Definition: hps.h:42816
void Right(bool in_state)
Definition: hps.h:41442
virtual void Reset()
Definition: hps.h:40508
Definition: hps.h:11721
HPS::Type ObjectType() const
Definition: hps.h:11278
bool Meta() const
Definition: hps.h:41068
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4057
Definition: hps.h:35372
TimerTickEvent()
Definition: hps.h:40536
Definition: hps.h:38368
Definition: hps.h:37084
HPS::Type ObjectType() const
Definition: hps.h:21994
RenderingAlgorithm
Definition: hps.h:268
EmergencyHandler()
Definition: hps.h:40051
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5770
TouchID ID
TouchID for this Touch.
Definition: hps.h:6429
Definition: hps.h:36344
HPS::Type ObjectType() const
Definition: hps.h:10844
HPS::Type ObjectType() const
Definition: hps.h:33254
HPS::Type ObjectType() const
Definition: hps.h:8429
Definition: hps.h:42811
Definition: hps.h:6168
Definition: hps.h:24356
HandednessOptimization
Definition: hps.h:362
Definition: hps.h:6710
Projection
Definition: hps.h:1388
Control(Control &&in_that)
Definition: hps.h:5651
bool Control() const
Definition: hps.h:41060
Definition: hps.h:5429
HPS::Type ObjectType() const
Definition: hps.h:34773
Overlay
Definition: hps.h:1278
Definition: hps.h:28721
Definition: hps.h:5962
Definition: hps.h:37182
Definition: hps.h:43117
HPS::Type ObjectType() const
Definition: hps.h:37970
size_t GetHash() const
Status
Definition: hps.h:6118
Definition: hps.h:22088
HPS::Type ObjectType() const
Definition: hps.h:34903
HPS::Type ObjectType() const
Definition: hps.h:6609
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:41645
Definition: hps.h:37351
Definition: hps.h:42182
Definition: hps.h:27028
Definition: hps.h:2020
HPS::Type ObjectType() const
Definition: hps.h:42112