hps.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef HPS_H
11 #define HPS_H
12 
13 #ifdef _MSC_VER
14 # ifndef STATIC_APP
15 # ifdef HPS_CORE_BUILD
16 # define HPS_API __declspec (dllexport)
17 # define EXPIMP_TEMPLATE
18 # else
19 # define HPS_API __declspec (dllimport)
20 # define EXPIMP_TEMPLATE extern
21 # endif
22 # define HPS_TEMPLATE_API __declspec (dllexport)
23 # endif
24 # ifdef _WINDOWS_
25 # undef Ellipse
26 # undef Polyline
27 # undef Polygon
28 # undef Rectangle
29 # undef min
30 # undef max
31 # endif
32 # pragma warning(push)
33 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
34 #else
35 # include <limits.h>
36 # include <stddef.h>
37 # ifdef LINUX_SYSTEM
38 # ifndef STATIC_APP
39 # ifdef HPS_CORE_BUILD
40 # define HPS_API __attribute__ ((visibility ("default")))
41 # define EXPIMP_TEMPLATE
42 # else
43 # define EXPIMP_TEMPLATE extern
44 # endif
45 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
46 # endif
47 # endif
48 #endif
49 #ifndef HPS_API
50 # define HPS_API
51 #endif
52 #ifndef HPS_TEMPLATE_API
53 # define HPS_TEMPLATE_API
54 #endif
55 #ifndef EXPIMP_TEMPLATE
56 # define EXPIMP_TEMPLATE
57 #endif
58 #ifndef ENUM_CLASS
59 # define ENUM_CLASS enum class
60 #endif
61 
62 #define NO_HPS_API
63 
64 #include <stdint.h>
65 #include <memory>
66 #include <vector>
67 #include <math.h>
68 #include <float.h>
69 #include <limits>
70 #include <stdexcept>
71 #include <algorithm>
72 #include <cstring>
73 
74 
75 namespace HPSI
76 {
77  class Impl;
78  class KeyImpl;
79  class TicketImpl;
80  class EventDispatcherImpl;
81  class AbstractImage;
82  class String;
83 };
84 
85 namespace HPS
86 {
87 
88  // unimplemented
89 
90 
91 //Begin Info
93 class HPS_API Info
94 {
95 public:
96 
99  enum class Code : uint32_t
100  {
101  Unknown,
102  Exchange,
103  Publish,
104  Data,
105  Key,
106  Geometry,
107  Database,
108  Driver,
109  Internal,
110  Memory,
111  System,
112  Unsupported,
113  DWG,
114  Parasolid,
115  };
116 
117 private:
118  Info() {}
119 };
120 
121 
122 //Begin Info
124 class HPS_API Emergency
125 {
126 public:
127 
130  enum class Code : uint32_t
131  {
132  Unknown,
133  Fatal,
134  SoftMemoryLimit,
135  HardMemoryLimit,
136  };
137 
138 private:
139  Emergency() {}
140 };
141 
142 
143 //Begin Window
145 class HPS_API Window
146 {
147 public:
148 
153  enum class Driver : uint32_t
154  {
155  Default3D,
156  OpenGL,
157  OpenGL2,
158  DirectX11,
159  Vulkan,
160  OpenGL2Mesa,
161  };
162 
165  enum class UpdateStatus : uint32_t
166  {
167  InProgress,
168  Completed,
169  TimedOut,
170  Interrupted,
171  Failed
172  };
173 
177  enum class UpdateType : uint32_t
178  {
180  Default,
181 
186  Complete,
187 
189  Refresh,
190 
192  CompileOnly,
193 
197  Exhaustive,
198  };
199 
202  enum class Mobility : uint32_t
203  {
204  Locked,
205  Floating,
206  FixedRatio,
207  Free
208  };
209 
212  enum class FrameSize : uint32_t
213  {
214  Single,
215  Double
216  };
217 
220  enum class FrameOptions : uint32_t
221  {
222  Inset,
223  Overlay
224  };
225 
228  enum class ImageFormat : uint32_t
229  {
230  Default,
231  RGBA,
232  RGB,
233  Jpeg,
234  Png
235  };
236 
237 private:
238  Window() {}
239 };
240 
241 //Begin Subwindow
243 class HPS_API Subwindow
244 {
245 public:
246  enum class Background : uint32_t
247  {
248  SolidColor,
249  Image,
250  Cubemap,
251  Blend,
252  Transparent,
253  Interactive,
254 
255  GradientTopToBottom,
256  GradientBottomToTop,
257  GradientLeftToRight,
258  GradientRightToLeft,
259  GradientTopLeftToBottomRight,
260  GradientTopRightToBottomLeft,
261  GradientBottomLeftToTopRight,
262  GradientBottomRightToTopLeft,
263  };
264 
265  enum class Type : uint32_t
266  {
267  Standard,
268  Lightweight
269  };
270 
271  enum class Border : uint32_t
272  {
273  None,
274  Inset,
275  InsetBold,
276  Overlay,
277  OverlayBold
278  };
279 
280 
282  enum class RenderingAlgorithm : uint32_t
283  {
286  ZBuffer,
287 
293  HiddenLine,
294 
300  FastHiddenLine,
301 
318  Priority
319  };
320 
321 private:
322  Subwindow() {}
323 };
324 //End Subwindow
325 
327 class HPS_API Style
328 {
329 public:
330 
333  enum class Type : uint32_t
334  {
335  Segment,
336  Named
337  };
338 
341  enum class AppendMode : uint32_t
342  {
343  None,
344  And,
345  Or
346  };
347 
348 private:
349  Style() {}
350 };
351 
352 
354 class HPS_API Shell
355 {
356 public:
357 
360  enum class Component : uint32_t
361  {
362  Faces,
363  Edges,
364  Vertices
365  };
366 
367  /* \enum ToleranceUnits
368  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
369  enum class ToleranceUnits : uint32_t
370  {
371  ObjectSpace,
372  FeatureSizePercentage
373  };
374 
375  /* \enum HandednessOptimization
376  * Enumerates the shell optimization options with regards to handedness. */
377  enum class HandednessOptimization : uint32_t
378  {
379  None,
380  Fix,
381  Reverse
382  };
383 
384  /* \enum RelationResults
385  * Enumerates the results of a shell relation computation. */
386  enum class Relation : uint32_t
387  {
388  On,
389  Off,
390  In,
391  Out
392  };
393 
394  /* \enum RelationTest
395  * Enumerates the test options for a shell relation computation. */
396  enum class RelationTest : uint32_t
397  {
398  Simple,
399  Enclosure,
400  Distance
401  };
402 
403 private:
404  Shell() {}
405 };
406 
407 
409 class HPS_API Mesh
410 {
411 public:
412 
415  enum class Component : uint32_t
416  {
417  Faces,
418  Edges,
419  Vertices
420  };
421 
422 private:
423  Mesh() {}
424 };
425 
426 
428 class HPS_API InfiniteLine
429 {
430 public:
431 
434  enum class Type : uint32_t
435  {
436  Line,
437  Ray
438  };
439 
440 private:
441  InfiniteLine() {}
442 };
443 
444 
446 class HPS_API Trim
447 {
448 public:
449 
452  enum class Type : uint32_t
453  {
454  Line,
455  Curve
456  };
457 
461  enum class Operation : uint32_t
462  {
463  Keep,
464  Remove
465  };
466 
467 private:
468  Trim() {}
469 };
470 
471 
473 class HPS_API Spotlight
474 {
475 public:
476 
479  enum class OuterConeUnits : uint32_t
480  {
484  Degrees,
488  FieldRadius
489  };
490 
493  enum class InnerConeUnits : uint32_t
494  {
498  Degrees,
502  FieldRadius,
505  Percent
506  };
507 
508 private:
509  Spotlight() {}
510 };
511 
512 
514 class HPS_API Cylinder
515 {
516 public:
517 
520  enum class Component : uint32_t
521  {
522  Faces,
523  Edges,
524  };
525 
528  enum class Capping : uint32_t
529  {
530  None,
531  First,
532  Last,
533  Both
534  };
535 
538  enum class Orientation : uint32_t
539  {
540  Default,
541  DefaultRadii,
542  InvertRadii,
543  InvertRadiiOnly,
544  DefaultColors,
545  InvertColors,
546  InvertColorsOnly,
547  InvertAll
548  };
549 
550 private:
551  Cylinder() {}
552 };
553 
554 
556 class HPS_API HighlightSearch
557 {
558 public:
559 
562  enum class Scope : uint32_t
563  {
564  AtOrAbovePath,
565  AtOrBelowPath,
566  ExactPath
567  };
568 
569 private:
570  HighlightSearch() {}
571 };
572 
574 class HPS_API Search
575 {
576 public:
577 
580  enum class Space : uint32_t
581  {
582  SegmentOnly,
583  Subsegments,
584  SubsegmentsAndIncludes
585  };
586 
589  enum class Behavior : uint32_t
590  {
591  Exhaustive,
592  FirstMatch
593  };
594 
597  enum class Type : uint32_t
598  {
599  None = 0x00000000,
600  Everything = 0x00ffffff,
601 
602  Include = 0x00000042,
603  Segment = 0x00000043,
604 
605  Includer = 0x00000100,
606 
607  // Geometry
608  Geometry = 0x10000000,
609 
610  CuttingSection = 0x10000026,
611  Shell = 0x10000028,
612  Mesh = 0x10000029,
613  Grid = 0x1000002a,
614  NURBSSurface = 0x1000002b,
615  Cylinder = 0x1000002d,
616  Sphere = 0x1000002e,
617  Polygon = 0x1000002f,
618  Circle = 0x10000030,
619  //unused = 0x10000031,
620  CircularWedge = 0x10000032,
621  Ellipse = 0x10000033,
622  Line = 0x10000034,
623  NURBSCurve = 0x10000037,
624  CircularArc = 0x10000038,
625  EllipticalArc = 0x10000039,
626  InfiniteLine = 0x1000003a,
627  //unused = 0x1000003b,
628  Marker = 0x1000003c,
629  Text = 0x1000003e,
630  Reference = 0x10000041,
631 
632  DistantLight = 0x10000100,
633  Spotlight = 0x10000101,
634  InfiniteRay = 0x10000102,
635 
636  // Attributes
637  Attribute = 0x20000000,
638 
639  Priority = 0x20000001,
640 
641  // Simple Attributes
642  Material = 0x2000000b,
643  PBRMaterial = 0x2000000c,
644  Camera = 0x2000000f,
645  ModellingMatrix = 0x20000011,
646  UserData = 0x20000022,
647  TextureMatrix = 0x20000024,
648 
649  // Complex Attributes
650  Culling = 0x20001000,
651  CullingBackFace = 0x20001001,
652  CullingExtent = 0x20001002,
653  CullingVector = 0x20001003,
654  CullingVectorTolerance = 0x20001004,
655  CullingFrustum = 0x20001005,
656  CullingDeferralExtent = 0x20001006,
657  CullingVolume = 0x20001007,
658  CullingDistance = 0x20001008,
659 
660  CurveAttribute = 0x20002000,
661  CurveAttributeBudget = 0x20002001,
662  CurveAttributeContinuedBudget = 0x20002002,
663  CurveAttributeViewDependent = 0x20002003,
664  CurveAttributeMaximumDeviation = 0x20002004,
665  CurveAttributeMaximumAngle = 0x20002005,
666  CurveAttributeMaximumLength = 0x20002006,
667 
668  CylinderAttribute = 0x20003000,
669  CylinderAttributeTessellation = 0x20003001,
670  CylinderAttributeOrientation = 0x20003002,
671 
672  EdgeAttribute = 0x20004000,
673  EdgeAttributePattern = 0x20004016,
674  EdgeAttributeWeight = 0x20004017,
675  EdgeAttributeHardAngle = 0x20004018,
676 
677  LightingAttribute = 0x20005000,
678  LightingAttributeInterpolation = 0x20005001,
679 
680  LineAttribute = 0x20006000,
681  LineAttributePattern = 0x2000601a,
682  LineAttributeWeight = 0x2000601b,
683 
684  MarkerAttribute = 0x20007000,
685  MarkerAttributeGlyphRotation = 0x2000701a,
686  MarkerAttributeSize = 0x2000701c,
687  MarkerAttributeSymbol = 0x2000701d,
688  MarkerAttributePreference = 0x2000701e,
689 
690  SurfaceAttribute = 0x20008000,
691  SurfaceAttributeBudget = 0x20008001,
692  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
693  SurfaceAttributeMaximumFacetAngle = 0x20008003,
694  SurfaceAttributeMaximumFacetWidth = 0x20008004,
695  SurfaceAttributeTrimCurveBudget = 0x20008005,
696  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
697 
698  Selectability = 0x20009000,
699  SelectabilityWindows = 0x20009001,
700  SelectabilityEdges = 0x20009002,
701  SelectabilityFaces = 0x20009003,
702  SelectabilityLights = 0x20009004,
703  SelectabilityLines = 0x20009005,
704  SelectabilityMarkers = 0x20009006,
705  SelectabilityVertices = 0x20009007,
706  SelectabilityText = 0x20009008,
707 
708  SphereAttribute = 0x2000a000,
709  SphereAttributeTessellation = 0x2000a001,
710 
711  Subwindow = 0x2000b000,
712  SubwindowEitherType = 0x2000b001,
713  SubwindowStandard = 0x2000b00e,
714  SubwindowLightweight = 0x2000b002,
715  SubwindowBackground = 0x2000b003,
716  SubwindowBorder = 0x2000b004,
717  SubwindowRenderingAlgorithm = 0x2000b005,
718 
719  TextAttribute = 0x2000c000,
720  TextAttributeAlignment = 0x2000c01e,
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 = 0x2000c020,
738  TextAttributeSpacing = 0x2000c021,
739  TextAttributeBackground = 0x2000c022,
740  TextAttributeBackgroundMargins = 0x2000c023,
741  TextAttributeBackgroundStyle = 0x2000c024,
742  TextAttributeLeaderLine = 0x2000c025,
743 
744  Transparency = 0x2000d000,
745  TransparencyMethod = 0x2000d001,
746  TransparencyAlgorithm = 0x2000d002,
747  TransparencyDepthPeelingLayers = 0x2000d004,
748  TransparencyDepthPeelingMinimumArea = 0x2000d005,
749  TransparencyDepthWriting = 0x2000d006,
750 
751  Visibility = 0x2000e000,
752  VisibilityCuttingSections = 0x2000e001,
753  VisibilityCutEdges = 0x2000e002,
754  VisibilityCutFaces = 0x2000e003,
755  VisibilityWindows = 0x2000e004,
756  VisibilityText = 0x2000e005,
757  VisibilityLines = 0x2000e006,
758  VisibilityEdgeLights = 0x2000e007,
759  VisibilityMarkerLights = 0x2000e008,
760  VisibilityFaceLights = 0x2000e009,
761  VisibilityGenericEdges = 0x2000e00a,
762  VisibilityHardEdges = 0x2000e00b,
763  VisibilityAdjacentEdges = 0x2000e00c,
764  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
765  VisibilityShadowEmitting = 0x2000e00e,
766  VisibilityShadowReceiving = 0x2000e00f,
767  VisibilityShadowCasting = 0x2000e010,
768  VisibilityMarkers = 0x2000e011,
769  VisibilityVertices = 0x2000e012,
770  VisibilityFaces = 0x2000e013,
771  VisibilityPerimeterEdges = 0x2000e014,
772  VisibilityNonCulledEdges = 0x2000e015,
773  VisibilityMeshQuadEdges = 0x2000e016,
774  VisibilityEdges = 0x2000e017,
775  VisibilityLeaderLines = 0x2000e018,
776 
777  VisualEffects = 0x2000f000,
778  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
779  VisualEffectsAntiAliasing = 0x2000f002,
780  VisualEffectsShadowMaps = 0x2000f003,
781  VisualEffectsSimpleShadow = 0x2000f004,
782  VisualEffectsSimpleShadowPlane = 0x2000f005,
783  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
784  VisualEffectsSimpleShadowColor = 0x2000f007,
785  VisualEffectsSimpleReflection = 0x2000f008,
786  VisualEffectsSimpleReflectionPlane = 0x2000f009,
787  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
788  VisualEffectsEyeDomeLightingBackColor = 0x2000f00b,
789 
790  Performance = 0x20010000,
791  PerformanceDisplayLists = 0x20010001,
792  PerformanceStaticModel = 0x20010002,
793  PerformanceTextHardwareAcceleration = 0x20010004,
794  StaticModelSegment = 0x40000043,
795 
796  DrawingAttribute = 0x20011000,
797  DrawingAttributePolygonHandedness = 0x20011001,
798  DrawingAttributeDepthRange = 0x20011002,
799  DrawingAttributeFaceDisplacement = 0x20011003,
800  DrawingAttributeGeneralDisplacement = 0x20011004,
801  DrawingAttributeVertexDisplacement = 0x20011005,
802  DrawingAttributeOverlay = 0x20011006,
803  DrawingAttributeDeferral = 0x20011007,
804  DrawingAttributeVertexDecimation = 0x20011008,
805  DrawingAttributeVertexRandomization = 0x20011009,
806  DrawingAttributeOverrideInternalColor = 0x2001100a,
807  DrawingAttributeClipRegion = 0x20011013,
808  DrawingAttributeWorldHandedness = 0x20011019,
809 
810 
811  HiddenLineAttribute = 0x20012000,
812  HiddenLineAttributeAlgorithm = 0x20012001,
813  HiddenLineAttributeColor = 0x20012002,
814  HiddenLineAttributeDimFactor = 0x20012003,
815  HiddenLineAttributeFaceDisplacement = 0x20012004,
816  HiddenLineAttributeLinePattern = 0x20012005,
817  HiddenLineAttributeLineSort = 0x20012006,
818  HiddenLineAttributeRenderFaces = 0x20012007,
819  HiddenLineAttributeRenderText = 0x20012008,
820  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
821  HiddenLineAttributeTransparencyCutoff = 0x2001200a,
822  HiddenLineAttributeVisibility = 0x2001200b,
823  HiddenLineAttributeWeight = 0x2001200c,
824 
825 
826  SegmentStyle = 0x20013001,
827  NamedStyle = 0x20013002,
828  MaterialPalette = 0x20013003,
829  Portfolio = 0x20013004,
830 
831  ContourLine = 0x20014000,
832  ContourLineVisibility = 0x20014001,
833  ContourLinePosition = 0x20014002,
834  ContourLineColor = 0x20014003,
835  ContourLinePattern = 0x20014004,
836  ContourLineWeight = 0x20014005,
837  ContourLineLighting = 0x20014006,
838 
839  Condition = 0x20015000,
840 
841  Bounding = 0x20016000,
842  BoundingVolume = 0x20016001,
843  BoundingExclusion = 0x20016002,
844 
845  AttributeLock = 0x20017000,
846  AttributeLockSetting = 0x20017001,
847  AttributeLockSubsegmentOverride = 0x20017002,
848 
849  TransformMask = 0x20018000,
850  TransformMaskCamera = 0x20018001,
851  TransformMaskCameraTranslation = 0x20018002,
852  TransformMaskCameraScale = 0x20018003,
853  TransformMaskCameraOffset = 0x20018004,
854  TransformMaskCameraRotation = 0x20018005,
855  TransformMaskCameraPerspectiveScale = 0x20018006,
856  TransformMaskCameraProjection = 0x20018007,
857  TransformMaskModellingMatrix = 0x20018008,
858  TransformMaskModellingMatrixTranslation = 0x20018009,
859  TransformMaskModellingMatrixScale = 0x20018010,
860  TransformMaskModellingMatrixOffset = 0x20018011,
861  TransformMaskModellingMatrixRotation = 0x20018012,
862 
863  ColorInterpolation = 0x20019000,
864  ColorInterpolationFaceColor = 0x20019001,
865  ColorInterpolationEdgeColor = 0x20019002,
866  ColorInterpolationMarkerColor = 0x20019003,
867  ColorInterpolationFaceIndex = 0x20019004,
868  ColorInterpolationEdgeIndex = 0x20019005,
869  ColorInterpolationMarkerIndex = 0x20019006,
870 
871  CuttingSectionAttribute = 0x2001a000,
872  CuttingSectionAttributeCuttingLevel = 0x2001a001,
873  CuttingSectionAttributeCappingLevel = 0x2001a002,
874  CuttingSectionAttributeMaterialPreference = 0x2001a003,
875  CuttingSectionAttributeEdgeWeight = 0x2001a004,
876  CuttingSectionAttributeTolerance = 0x2001a005,
877  CuttingSectionAttributeCappingUsage = 0x2001a006,
878 
879  };
880 
881 private:
882  Search() {}
883 };
884 
885 
887 class HPS_API Material
888 {
889 public:
890 
893  enum class Type : uint32_t
894  {
895  None = 0,
896  FullMaterial,
897  RGBColor,
898  RGBAColor,
899  MaterialIndex,
900  TextureName,
901  ModulatedTexture,
902  CubeMapName,
903  ModulatedCubeMap,
904  GlossValue,
905  DiffuseChannelAlpha
906  };
907 
910  enum class Channel : uint32_t
911  {
912  DiffuseColor = 1,
913  DiffuseTexture = 2,
914  Specular = 3,
915  Emission = 4,
916  Transmission = 5,
917  Mirror = 6,
918  Bump = 7,
919  EnvironmentTexture = 8,
920  EnvironmentCubeMap = 9,
921  Gloss = 10,
922  Alpha = 11
923  };
924 
926  class HPS_API Color
927  {
928  public:
929 
932  enum class Channel : uint32_t
933  {
934  DiffuseColor = 1,
935  Specular = 3,
936  Emission = 4,
937  Mirror = 6
938  };
939 
940  private:
941  Color() {}
942  };
943 
945  class HPS_API Texture
946  {
947  public:
948 
951  enum class Channel : uint32_t
952  {
953  DiffuseTexture = 2,
954  Specular = 3,
955  Emission = 4,
956  Transmission = 5,
957  Mirror = 6,
958  Bump = 7,
959  EnvironmentTexture = 8,
960  EnvironmentCubeMap = 9
961  };
962 
965  enum class Parameterization : uint32_t
966  {
968  Cylinder,
969 
971  PhysicalReflection,
972 
974  Object,
975 
981  NaturalUV,
982 
984  ReflectionVector,
985 
987  SurfaceNormal,
988 
990  Sphere,
991 
993  UV,
994 
996  World
997  };
998 
1001  enum class Tiling : uint32_t
1002  {
1005  Clamp,
1006 
1008  Repeat,
1009 
1011  Reflect,
1012 
1015  Trim
1016  };
1017 
1020  enum class Interpolation : uint32_t
1021  {
1023  None,
1024 
1026  Bilinear
1027  };
1028 
1031  enum class Decimation : uint32_t
1032  {
1034  None,
1035 
1038  Anisotropic,
1039 
1041  Mipmap
1042  };
1043 
1047  enum class ChannelMapping : uint32_t
1048  {
1049  Red,
1050  Green,
1051  Blue,
1052  Alpha,
1053  Zero,
1054  One,
1055  Luminance
1056  };
1057 
1058  private:
1059  Texture() {}
1060  };
1061 
1062 private:
1063  Material() {}
1064 };
1065 
1066 
1067 class HPS_API PostProcessEffects
1068 {
1069 public:
1070 
1071  class HPS_API AmbientOcclusion
1072  {
1073  public:
1074 
1077  enum class Quality : uint32_t
1078  {
1079  Fastest,
1080  Nicest
1081  };
1082 
1083  private:
1084  AmbientOcclusion() {}
1085  };
1086 
1087  class HPS_API Bloom
1088  {
1089  public:
1093  enum class Shape : uint32_t
1094  {
1095  Star,
1096  Radial
1097  };
1098 
1099  private:
1100  Bloom() {}
1101  };
1102 
1103 private:
1104  PostProcessEffects() {}
1105 };
1106 
1107 class HPS_API Performance
1108 {
1109 public:
1110 
1114  enum class DisplayLists : uint32_t
1115  {
1117  None,
1118 
1121  Geometry,
1122 
1125  Segment
1126  };
1127 
1136  enum class StaticModel : uint32_t
1137  {
1138  None,
1139  Attribute,
1140  AttributeSpatial
1141  };
1142 
1148  enum class StaticConditions : uint32_t
1149  {
1153  Independent,
1154 
1161  Single
1162 
1163  /* placeholder. Option would generate different optimized trees at the cost of memory. */
1164  //Multiple //!< An optimized segment tree will be used for rendering. The tree will be sorted based on both attributes and spatial locations of objects. This is particularly useful for very large, spatially dispersed models.
1165  };
1166 
1167 
1168 private:
1169  Performance() {}
1170 };
1171 
1172 
1173 class HPS_API AttributeLock
1174 {
1175 public:
1176 
1178  enum class Type : uint32_t
1179  {
1180  Everything = 0x01000000,
1181 
1182  Visibility = 0x02000000,
1183 
1184  VisibilityCuttingSections,
1185  VisibilityCutEdges,
1186  VisibilityCutFaces,
1187  VisibilityWindows,
1188  VisibilityText,
1189  VisibilityLines,
1190  VisibilityEdgeLights,
1191  VisibilityMarkerLights,
1192  VisibilityFaceLights,
1193  VisibilityGenericEdges,
1194  VisibilityHardEdges,
1195  VisibilityAdjacentEdges,
1196  VisibilityInteriorSilhouetteEdges,
1197  VisibilityShadowEmitting,
1198  VisibilityShadowReceiving,
1199  VisibilityShadowCasting,
1200  VisibilityMarkers,
1201  VisibilityVertices,
1202  VisibilityFaces,
1203  VisibilityPerimeterEdges,
1204  VisibilityNonCulledEdges,
1205  VisibilityMeshQuadEdges,
1206  VisibilityCutGeometry,
1207  VisibilityEdges,
1208  VisibilityGeometry,
1209  VisibilityLights,
1210  VisibilityShadows,
1211 
1212  Material = 0x03000000,
1213 
1214  MaterialGeometry,
1215  MaterialCutGeometry,
1216 
1217  MaterialAmbientLightUpColor,
1218  MaterialAmbientLightDownColor,
1219  MaterialAmbientLightColor,
1220 
1221  MaterialWindowColor,
1222  MaterialWindowContrastColor,
1223 
1224  MaterialLightColor,
1225  MaterialLineColor,
1226  MaterialMarkerColor,
1227  MaterialTextColor,
1228  MaterialCutEdgeColor,
1229 
1230  MaterialVertex,
1231  MaterialVertexDiffuse,
1232  MaterialVertexDiffuseColor,
1233  MaterialVertexDiffuseAlpha,
1234  MaterialVertexDiffuseTexture,
1235  MaterialVertexSpecular,
1236  MaterialVertexMirror,
1237  MaterialVertexTransmission,
1238  MaterialVertexEmission,
1239  MaterialVertexEnvironment,
1240  MaterialVertexBump,
1241  MaterialVertexGloss,
1242 
1243  MaterialEdge,
1244  MaterialEdgeDiffuse,
1245  MaterialEdgeDiffuseColor,
1246  MaterialEdgeDiffuseAlpha,
1247  MaterialEdgeDiffuseTexture,
1248  MaterialEdgeSpecular,
1249  MaterialEdgeMirror,
1250  MaterialEdgeTransmission,
1251  MaterialEdgeEmission,
1252  MaterialEdgeEnvironment,
1253  MaterialEdgeBump,
1254  MaterialEdgeGloss,
1255 
1256  MaterialFace,
1257  MaterialFaceDiffuse,
1258  MaterialFaceDiffuseColor,
1259  MaterialFaceDiffuseAlpha,
1260  MaterialFaceDiffuseTexture,
1261  MaterialFaceSpecular,
1262  MaterialFaceMirror,
1263  MaterialFaceTransmission,
1264  MaterialFaceEmission,
1265  MaterialFaceEnvironment,
1266  MaterialFaceBump,
1267  MaterialFaceGloss,
1268 
1269  MaterialBackFace,
1270  MaterialBackFaceDiffuse,
1271  MaterialBackFaceDiffuseColor,
1272  MaterialBackFaceDiffuseAlpha,
1273  MaterialBackFaceDiffuseTexture,
1274  MaterialBackFaceSpecular,
1275  MaterialBackFaceMirror,
1276  MaterialBackFaceTransmission,
1277  MaterialBackFaceEmission,
1278  MaterialBackFaceEnvironment,
1279  MaterialBackFaceBump,
1280  MaterialBackFaceGloss,
1281 
1282  MaterialFrontFace,
1283  MaterialFrontFaceDiffuse,
1284  MaterialFrontFaceDiffuseColor,
1285  MaterialFrontFaceDiffuseAlpha,
1286  MaterialFrontFaceDiffuseTexture,
1287  MaterialFrontFaceSpecular,
1288  MaterialFrontFaceMirror,
1289  MaterialFrontFaceTransmission,
1290  MaterialFrontFaceEmission,
1291  MaterialFrontFaceEnvironment,
1292  MaterialFrontFaceBump,
1293  MaterialFrontFaceGloss,
1294 
1295  MaterialCutFace,
1296  MaterialCutFaceDiffuse,
1297  MaterialCutFaceDiffuseColor,
1298  MaterialCutFaceDiffuseAlpha,
1299  MaterialCutFaceDiffuseTexture,
1300  MaterialCutFaceSpecular,
1301  MaterialCutFaceMirror,
1302  MaterialCutFaceTransmission,
1303  MaterialCutFaceEmission,
1304  MaterialCutFaceEnvironment,
1305  MaterialCutFaceBump,
1306  MaterialCutFaceGloss,
1307 
1308  Camera = 0x04000000,
1309  };
1310 
1311 private:
1312  AttributeLock() {}
1313 };
1314 
1315 class HPS_API Drawing
1316 {
1317 public:
1318 
1321  enum class Handedness : uint32_t
1322  {
1323  None,
1324  Left,
1325  Right
1326  };
1327 
1330  enum class Overlay : uint32_t
1331  {
1333  None,
1334 
1337  Default,
1338 
1341  WithZValues,
1342 
1347  InPlace,
1348  };
1349 
1352  enum class ClipOperation : uint32_t
1353  {
1354  Keep,
1355  Remove,
1356  };
1357 
1360  enum class ClipSpace : uint32_t
1361  {
1362  Window,
1363  World,
1364  Object,
1365  };
1366 
1367 private:
1368  Drawing() {}
1369 };
1370 
1371 
1372 class HPS_API HiddenLine
1373 {
1374 public:
1375 
1379  enum class Algorithm : uint32_t
1380  {
1381  None,
1382  ZBuffer,
1383  ZSort,
1384  };
1385 
1386 private:
1387  HiddenLine() {}
1388 };
1389 
1390 
1392 class HPS_API Selection
1393 {
1394 public:
1395 
1398  enum class Level : uint32_t
1399  {
1400  Segment,
1401  Entity,
1402  Subentity,
1403  };
1404 
1407  enum class Sorting: uint32_t
1408  {
1409  Off,
1410 
1417  Proximity,
1418 
1419  ZSorting,
1420 
1421  Default
1422  };
1423 
1426  enum class Algorithm : uint32_t
1427  {
1430  Visual,
1431 
1434  Analytic
1435  };
1436 
1439  enum class Granularity : uint32_t
1440  {
1441  General,
1442  Detailed
1443  };
1444 
1445 private:
1446  Selection() {}
1447 };
1448 
1449 
1453 
1455 class HPS_API Camera
1456 {
1457 public:
1458 
1461  enum class Projection : uint32_t
1462  {
1463  Default = 1 ,
1464  Perspective,
1465  Orthographic,
1466  Stretched,
1467  };
1468 
1469 private:
1470  Camera() {}
1471 };
1472 
1473 
1475 class HPS_API Selectability
1476 {
1477 public:
1481  enum class Value : uint32_t
1482  {
1483  Off = 0,
1484  On,
1485  ForcedOn
1486  };
1487 
1488 private:
1489  Selectability() {}
1490 };
1491 
1492 
1494 class HPS_API Transparency
1495 {
1496 public:
1497 
1500  enum class Method : uint32_t
1501  {
1502  None,
1503  Blended,
1504  ScreenDoor
1505  };
1506 
1509  enum class Algorithm : uint32_t
1510  {
1511  None,
1512  Painters,
1513  ZSortNicest,
1514  ZSortFastest,
1515  DepthPeeling,
1516  WeightedBlended
1517  };
1518 
1522  enum class AreaUnits : uint32_t
1523  {
1524  Percent,
1525  Pixels
1526  };
1527 
1531  enum class Preference
1532  {
1533  Nicest,
1534  Fastest,
1535  };
1536 
1537 private:
1538  Transparency() {}
1539 };
1540 
1541 
1543 class HPS_API Marker
1544 {
1545 public:
1547  enum class DrawingPreference : uint32_t
1548  {
1549  Nicest, // !< Markers should always be drawn at the requested size at the possible cost of performance.
1550  Fastest,
1551  };
1552 
1555  enum class SizeUnits : uint32_t
1556  {
1557  ScaleFactor,
1558  ObjectSpace,
1559  SubscreenRelative,
1560  WindowRelative,
1561  WorldSpace,
1562  Points,
1563  Pixels
1564  };
1565 
1566 private:
1567  Marker() {}
1568 };
1569 
1570 
1572 class HPS_API Lighting
1573 {
1574 public:
1575 
1578  enum class InterpolationAlgorithm : uint32_t
1579  {
1580  Phong,
1581  Gouraud,
1582  Flat
1583  };
1584 
1585 private:
1586  Lighting() {}
1587 };
1588 
1590 class HPS_API Text
1591 {
1592 public:
1593 
1596  enum class Alignment : uint32_t
1597  {
1598  TopLeft,
1599  CenterLeft,
1600  BottomLeft,
1601  TopCenter,
1602  Center,
1603  BottomCenter,
1604  TopRight,
1605  CenterRight,
1606  BottomRight
1607  };
1608 
1611  enum class ReferenceFrame : uint32_t
1612  {
1613  WorldAligned,
1614  PathAligned
1615  };
1616 
1619  enum class Justification : uint32_t
1620  {
1621  Left,
1622  Right,
1623  Center
1624  };
1625 
1628  enum class Transform : uint32_t
1629  {
1631  Transformable,
1634  NonTransformable,
1636  CharacterPositionOnly,
1639  CharacterPositionAdjusted,
1641  NonScalingTransformable
1642  };
1643 
1646  enum class Renderer : uint32_t
1647  {
1648  Default,
1649  Driver,
1650  Truetype,
1651  };
1652 
1655  enum class Preference : uint32_t
1656  {
1657  Default,
1658  Vector,
1659  Raster,
1660  Exterior
1661  };
1662 
1665  enum class Rotation : uint32_t
1666  {
1667  None,
1668  Rotate,
1669  FollowPath
1670  };
1671 
1672 
1675  enum class SizeUnits : uint32_t
1676  {
1677  ObjectSpace,
1678  SubscreenRelative,
1679  WindowRelative,
1680  WorldSpace,
1681  Points,
1682  Pixels
1683  };
1684 
1687  enum class SizeToleranceUnits : uint32_t
1688  {
1689  ObjectSpace,
1690  SubscreenRelative,
1691  WindowRelative,
1692  WorldSpace,
1693  Points,
1694  Pixels,
1695  Percent
1696  };
1697 
1700  enum class MarginUnits : uint32_t
1701  {
1702  ObjectSpace,
1703  SubscreenRelative,
1704  WindowRelative,
1705  WorldSpace,
1706  Points,
1707  Pixels,
1708  Percent
1709  };
1710 
1713  enum class GreekingUnits : uint32_t
1714  {
1715  ObjectSpace,
1716  SubscreenRelative,
1717  WindowRelative,
1718  WorldSpace,
1719  Points,
1720  Pixels
1721  };
1722 
1725  enum class GreekingMode : uint32_t
1726  {
1727  Nothing,
1728  Lines,
1729  Box
1730  };
1731 
1734  enum class RegionAlignment : uint32_t
1735  {
1736  Top,
1737  Center,
1738  Bottom
1739  };
1740 
1743  enum class LeaderLineSpace : uint32_t
1744  {
1745  Object,
1746  World,
1747  };
1748 
1751  enum class RegionFitting : uint32_t
1752  {
1753  Left,
1754  Center,
1755  Right,
1756  Spacing,
1757  Width,
1758  Auto,
1759  };
1760 private:
1761  Text() {}
1762 };
1763 
1764 
1766 class HPS_API Line
1767 {
1768 public:
1769 
1773  enum class CoordinateSpace : uint32_t
1774  {
1775  Object,
1776  World,
1777  NormalizedInnerWindow,
1778  NormalizedInnerPixel
1779  };
1780 
1784  enum class SizeUnits : uint32_t
1785  {
1786  ScaleFactor,
1787  ObjectSpace,
1788  SubscreenRelative,
1789  WindowRelative,
1790  WorldSpace,
1791  Points,
1792  Pixels
1793  };
1794 
1795 private:
1796  Line() {}
1797 };
1798 
1799 
1801 class HPS_API Edge
1802 {
1803 public:
1804 
1807  enum class SizeUnits : uint32_t
1808  {
1809  ScaleFactor,
1810  ObjectSpace,
1811  SubscreenRelative,
1812  WindowRelative,
1813  WorldSpace,
1814  Points,
1815  Pixels
1816  };
1817 
1818 private:
1819  Edge() {}
1820 };
1821 
1822 
1824 class HPS_API CuttingSection
1825 {
1826 public:
1827 
1830  enum class Mode : uint32_t
1831  {
1832  None,
1833  Round,
1834  Square,
1835  Plane
1836  };
1837 
1840  enum class CappingLevel : uint32_t
1841  {
1842  Entity,
1843  Segment,
1844  SegmentTree
1845  };
1846 
1849  enum class CappingUsage : uint32_t
1850  {
1851  Off,
1852  On,
1853  Visibility
1854  };
1855 
1858  enum class ToleranceUnits : uint32_t
1859  {
1860  Percent,
1861  WorldSpace,
1862  };
1863 
1866  enum class CuttingLevel : uint32_t
1867  {
1868  Global,
1869  Local,
1870  };
1871 
1874  enum class MaterialPreference : uint32_t
1875  {
1876  Explicit,
1877  Implicit,
1878  };
1879 
1882  enum class GatheringLevel : uint32_t
1883  {
1884  Segment,
1885  SegmentTree
1886  };
1887 
1888 private:
1889  CuttingSection() {}
1890 };
1891 
1893 class HPS_API ContourLine
1894 {
1895 public:
1896 
1900  enum class Mode : uint32_t
1901  {
1902  Repeating,
1903  Explicit,
1904  };
1905 
1906 private:
1907  ContourLine() {}
1908 };
1909 
1912 enum class IOResult : uint32_t
1913 {
1914  Success,
1915  Failure,
1916  FileNotFound,
1917  UnableToOpenFile,
1918  InvalidOptions,
1919  InvalidSegment,
1920  InProgress,
1921  Canceled,
1922  UnableToLoadLibraries,
1923  VersionIncompatibility,
1924  InitializationFailed,
1925  UnsupportedFormat,
1926  InvalidFile,
1927 };
1928 
1930 class HPS_API LinePattern
1931 {
1932 public:
1933 
1936  enum class SizeUnits : uint32_t
1937  {
1938  ObjectSpace,
1939  SubscreenRelative,
1940  WindowRelative,
1941  WorldSpace,
1942  Points,
1943  Pixels,
1944  ScaleFactor
1945  };
1946 
1949  enum class InsetBehavior : uint32_t
1950  {
1951  Overlap,
1952  Trim,
1953  Inline
1954  };
1955 
1959  enum class Join : uint32_t
1960  {
1961  Mitre,
1962  Round,
1963  Bevel
1964  };
1965 
1968  enum class Cap : uint32_t
1969  {
1972  Butt,
1975  Square,
1978  Round,
1980  Mitre
1981  };
1982 
1985  enum class Justification : uint32_t
1986  {
1989  Center,
1991  Stretch
1992  };
1993 
1996  enum class Modifier : uint32_t
1997  {
1998  GlyphName,
1999  Enumerated
2000  };
2001 
2002 
2016  enum class Default : uint32_t
2017  {
2018  Solid,
2019  DashDot,
2020  Dashed,
2021  Dotted,
2022  Dash2Dot,
2023  Dash3Dot,
2024  LongDash,
2025  LongDashShortDash,
2026  LongDash2ShortDash,
2027  FineDot,
2028  };
2029 
2030 private:
2031  LinePattern() {}
2032 };
2033 
2034 
2036 class HPS_API Shape
2037 {
2038 public:
2039  enum class Default : uint32_t
2040  {
2041  Rectangle,
2042  RoundedRectangle,
2043  Oval,
2044  Ellipse,
2045  };
2046 
2047 private:
2048  Shape() {}
2049 };
2050 
2051 
2052 //Begin Glyphs
2054 class HPS_API Glyph
2055 {
2056 public:
2057 
2060  enum class Fill : uint32_t
2061  {
2062  None,
2063  Continuous,
2064  New,
2065  NewLoop
2066  };
2067 
2070  enum class ColorSource : uint32_t
2071  {
2072  Default,
2073  Explicit,
2074  Indexed
2075  };
2076 
2080  enum class Default : uint32_t
2081  {
2082  Circle,
2083  CircleWithDot,
2084  CircleWithPlus,
2085  CircleWithTimes,
2086  CircleWithCircle,
2087  SolidCircle,
2088  Dot,
2089  Plus,
2090  Times,
2091  Splat,
2092  Box,
2093  BoxWithDot,
2094  BoxWithTimes,
2095  SolidBox,
2096  Diamond,
2097  DiamondWithDot,
2098  DiamondWithPlus,
2099  SolidDiamond,
2100  TriangleUp,
2101  TriangleUpWithDot,
2102  SolidTriangleUp,
2103  TriangleDown,
2104  TriangleDownWithDot,
2105  SolidTriangleDown,
2106  TriangleRight,
2107  TriangleRightWithDot,
2108  SolidTriangleRight,
2109  TriangleLeft,
2110  TriangleLeftWithDot,
2111  SolidTriangleLeft,
2112  TriangleUpV,
2113  SolidTriangleUpV,
2114  TriangleDownV,
2115  SolidTriangleDownV,
2116  TriangleRightV,
2117  SolidTriangleRightV,
2118  TriangleLeftV,
2119  SolidTriangleLeftV,
2120  LetterY,
2121  LetterZ,
2122  CircleLetterY,
2123  CircleLetterZ,
2124  VerticalBar,
2125  HorizontalBar,
2126  SlantLeft,
2127  SlantRight,
2128  WidePlus,
2129  SolidWidePlus,
2130  WideTimes,
2131  SolidWideTimes,
2132  Pound,
2133  Sphere,
2134  };
2135 
2136 private:
2137  Glyph() {}
2138 };
2139 
2140 
2142 class HPS_API Bounding
2143 {
2144 public:
2145 
2148  enum class Type : uint32_t
2149  {
2150  None,
2151  Sphere,
2152  Cuboid
2153  };
2154 
2155 private:
2156  Bounding() {}
2157 };
2158 
2159 
2161 class HPS_API Condition
2162 {
2163 public:
2164 
2165  enum class Intrinsic : uint32_t
2166  {
2167  Extent,
2168  DrawPass,
2169  InnerPixelWidth,
2170  InnerPixelHeight,
2171  Selection,
2172  QuickMovesProbe,
2173  };
2174 
2175 private:
2176  Condition() {}
2177 };
2178 
2179 
2181 class HPS_API Grid
2182 {
2183 public:
2184 
2187  enum class Type : uint32_t
2188  {
2189  Quadrilateral,
2190  Radial
2191  };
2192 
2193 private:
2194  Grid() {}
2195 };
2196 
2197 
2199 {
2200 public:
2201 
2202  enum class UserData : uint32_t
2203  {
2204  None,
2205  Discard,
2206  Preserve,
2207  Merge,
2208  Localize,
2209  };
2210 
2211  enum class Scope : uint32_t
2212  {
2213  SubSegments,
2214  SubsegmentsAndIncludes,
2215  SegmentOnly,
2216  };
2217 
2218  enum class Expansion : uint32_t
2219  {
2220  None,
2221  Includes,
2222  References,
2223  IncludesAndReferences,
2224  };
2225 
2226  enum class Matrix : uint32_t
2227  {
2228  None,
2229  Localize,
2230  Collapse,
2231  };
2232 
2233  enum class Reorganization : uint32_t
2234  {
2235  None,
2236  Attribute,
2237  Spatial,
2238  AttributeSpatial,
2239  };
2240 
2241 private:
2243 };
2244 
2245 
2247 class HPS_API Coordinate
2248 {
2249 public:
2250 
2254  enum class Space : uint32_t
2255  {
2256  Object,
2257  World,
2258  Camera,
2259  Window,
2260  Pixel,
2261  InnerWindow,
2262  InnerPixel,
2263  NormalizedInnerWindow,
2264  NormalizedInnerPixel,
2265  NormalizedWindow,
2266  NormalizedPixel,
2267  };
2268 
2269 private:
2270  Coordinate() {}
2271 };
2272 
2274 class HPS_API Extent
2275 {
2276 public:
2277 
2278  enum class ClipRegion : uint32_t
2279  {
2280  Include,
2281  Ignore
2282  };
2283 
2284 private:
2285  Extent() {}
2286 };
2287 
2288 class HPS_API GPU
2289 {
2290 public:
2291 
2296  enum class Preference
2297  {
2298  HighPerformance,
2299  Integrated,
2300  Specific,
2301  Default,
2302  };
2303 
2304 private:
2305  GPU() {}
2306 };
2307 
2308  typedef double Time;
2309 
2310 #ifdef _MSC_VER
2311 # ifndef HPS_INLINE
2312 # define HPS_INLINE __forceinline
2313 # endif
2314 #else
2315 # define HPS_INLINE inline
2316 #endif
2317 
2318 #ifndef HPS_UNREFERENCED
2319 #define HPS_UNREFERENCED(param) ((void)(param))
2320 #endif
2321 
2322 
2323 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2324 
2325 template<typename T>
2326 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2327 {
2328  return degrees * (T)(PI / 180.0);
2329 }
2330 
2331 template<typename T>
2332 HPS_INLINE T Radians_To_Degrees(T const & radians)
2333 {
2334  return radians * (T)(180.0 / PI);
2335 }
2336 
2337 template<typename T>
2338 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2339  T a = Degrees_To_Radians(angle);
2340  cosine = cos(a);
2341  sine = sin(a);
2342 }
2343 
2344 template<typename T>
2345 HPS_INLINE T Cos(T const & angle) {
2346  return cos (Degrees_To_Radians(angle));
2347 }
2348 
2349 template<typename T>
2350 HPS_INLINE T Sin(T const & angle) {
2351  return sin (Degrees_To_Radians(angle));
2352 }
2353 
2354 template<typename T>
2355 HPS_INLINE T ACos(T const & x) {
2356  if (x > 1)
2357  return 0;
2358  if (x < -1)
2359  return 180;
2360  return Radians_To_Degrees(acos(x));
2361 }
2362 
2363 template<typename T>
2364 HPS_INLINE T ATan2(T const & y, T const & x) {
2365  if (x == 0 && y == 0)
2366  return 0;
2367  return Radians_To_Degrees(atan2(y, x));
2368 }
2369 
2370 
2371 template <typename F> struct Float_Traits {};
2372 template <> struct Float_Traits<float> {
2373  typedef double Alternative;
2374  static const int Type = 1;
2375  static float Epsilon () { return 1.0e-30f; }
2376 };
2377 template <> struct Float_Traits<double> {
2378  typedef float Alternative;
2379  static const int Type = 2;
2380  static double Epsilon () { return 1.0e-300; }
2381 };
2382 
2383 
2384 
2386 class HPS_API Float {
2387 private:
2388  enum Parts {
2389 # if HOOPS_BIGENDIAN
2390  High, Low
2391 # else
2392  Low, High
2393 # endif
2394  };
2395 
2396  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2397  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2398  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2399  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2400  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2401 
2402  static HPS_INLINE bool is_nan(int32_t const & v) {
2403  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2404  return exp == 0x7F800000 && mantissa != 0;
2405  }
2406  static HPS_INLINE bool is_nan(uint32_t const & v) {
2407  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2408  return exp == 0x7F800000 && mantissa != 0;
2409  }
2410  static HPS_INLINE bool is_nan(int32_t const * v) {
2411  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2412  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2413  }
2414  static HPS_INLINE bool is_nan(uint32_t const * v) {
2415  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2416  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2417  }
2418 
2419  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2420  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2421  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FF00000) == 0x7FF00000; }
2422  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FF00000) == 0x7FF00000; }
2423 public:
2424 
2426  static const float Infinity;
2428  static const float NegativeInfinity;
2429 
2431  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2432  static HPS_INLINE bool IsInfinite(double const & a) {
2433  uint32_t v[2];
2434  memcpy (v, &a, sizeof(double));
2435  return is_infinite (v);
2436  }
2437 
2439  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2440  static HPS_INLINE bool IsNAN(double const & a) {
2441  uint32_t v[2];
2442  memcpy (v, &a, sizeof(double));
2443  return is_nan (v);
2444  }
2445 
2447  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2448  static HPS_INLINE bool IsAbnormal(double const & a) {
2449  uint32_t v[2];
2450  memcpy (v, &a, sizeof(double));
2451  return is_special (v);
2452  }
2453 
2456  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2457  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2458 
2459 #ifndef HOOPS_DEFINED
2460  template <typename Alloc>
2461  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2462  {
2463  if (a.size() != b.size())
2464  return false;
2465 
2466  auto it1 = a.begin();
2467  auto it2 = b.begin();
2468  auto const end = a.end();
2469  for ( ; it1 != end; ++it1, ++it2)
2470  {
2471  if (!Equals(*it1, *it2, tolerance))
2472  return false;
2473  }
2474  return true;
2475  }
2476 #endif
2477 
2478  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2479  return extract_uint32_t(a) & 0x80000000;
2480  }
2481  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2482  uint32_t v[2];
2483  memcpy (v, &a, sizeof(double));
2484  return v[High] & 0x80000000;
2485  }
2486 
2487  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2488  uint32_t v = extract_uint32_t(a);
2489  v &= 0x7FFFFFFF;
2490  v |= sign_bit;
2491  inject_uint32_t(a, v);
2492  }
2493  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2494  uint32_t v[2];
2495  memcpy (v, &a, sizeof(double));
2496  v[High] &= 0x7FFFFFFF;
2497  v[High] |= sign_bit;
2498  memcpy (&a, v, sizeof(double));
2499  }
2500 
2501 
2502  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2503  uint32_t v = extract_uint32_t(a);
2504 
2505  v &= 0x7FFFFFFF;
2506  if (v < 0x3B800000)
2507  return 0;
2508 
2509  v--;
2510 
2511  uint32_t exp = v >> 23;
2512  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2513 
2514  return (unsigned char) (man >> (16 + 126 - exp));
2515  }
2516 
2517  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2518  uint32_t v = extract_uint32_t(a);
2519 
2520  v &= 0x7FFFFFFF;
2521  if (v < 0x3B800000)
2522  return 0;
2523 
2524  v--;
2525 
2526  uint32_t exp = v >> 23;
2527  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2528 
2529  uint32_t x = (man >> (16 + 126 - exp));
2530 
2531  return (unsigned char) ((x * (mix+1)) >> 8);
2532  }
2533 
2534 
2535  static HPS_INLINE bool match(float const & a, float const & b) {
2536  uint32_t va = extract_uint32_t(a);
2537  uint32_t vb = extract_uint32_t(b);
2538 
2539  if (((va | vb) & 0x7FFFFFFF) == 0)
2540  return true;
2541 
2542  return va == vb;
2543  }
2544  static HPS_INLINE bool match(double const & a, double const & b) {
2545  return a == b;
2546  }
2547 
2548 
2549  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2550  if (b < a)
2551  a = b;
2552  }
2553  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2554  if (b < a)
2555  a = b;
2556  }
2557 
2558  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2559  if (b > a)
2560  a = b;
2561  }
2562  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2563  if (b > a)
2564  a = b;
2565  }
2566 
2567 
2568  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2569  uint32_t i;
2570  memcpy(&i, &a, sizeof(float));
2571  return i;
2572  }
2573 
2574  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2575  memcpy(&a, &i, sizeof(float));
2576  }
2577 
2578  static HPS_INLINE float C2F(unsigned char x) {
2579  //return (float)x * (1.0f/255.0f);
2580  return char_to_float[x];
2581  }
2582 
2583 
2584  // SSE convenience functions
2585  static HPS_INLINE void pack_4(float const & f, float * m) {
2586  memcpy(&m[0], &f, sizeof(float));
2587  memcpy(&m[1], &f, sizeof(float));
2588  memcpy(&m[2], &f, sizeof(float));
2589  memcpy(&m[3], &f, sizeof(float));
2590  }
2591 
2592  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2593  memcpy(&m[0], &f0, sizeof(float));
2594  memcpy(&m[1], &f1, sizeof(float));
2595  memcpy(&m[2], &f2, sizeof(float));
2596  memcpy(&m[3], &f3, sizeof(float));
2597  }
2598 
2599  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2600  memcpy(f0, m, sizeof(float)*4);
2601  }
2602 
2603  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2604  memcpy(&f0, &m[0], sizeof(float));
2605  memcpy(&f1, &m[1], sizeof(float));
2606  memcpy(&f2, &m[2], sizeof(float));
2607  memcpy(&f3, &m[3], sizeof(float));
2608  }
2609 
2610 private:
2611  static const float char_to_float[256];
2612 
2613  Float();
2614 };
2615 
2616 
2618 
2619 
2620 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2621 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2622 
2623 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2624 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2625 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2626 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2627 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2628 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2629 
2630 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2631 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2632 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); }
2633 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); }
2634 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); }
2635 
2636 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2637 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2638 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); }
2639 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); }
2640 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); }
2641 
2642 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; }
2643 
2644 
2645 template <> HPS_INLINE float Abs<float> (float const & a) {
2646  uint32_t v = Float::extract_uint32_t(a);
2647  v &= 0x7FFFFFFF;
2648  float f;
2649  Float::inject_uint32_t(f,v);
2650  return f;
2651 }
2652 
2653 template <> HPS_INLINE int Sign<float> (float const & a) {
2654  uint32_t v = Float::extract_uint32_t(a);
2655 
2656  if ((v & 0x7FFFFFFF) == 0)
2657  return 0;
2658 
2659  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2660 }
2661 
2662 
2664 
2665 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2666  int32_t va = Float::extract_uint32_t(a);
2667  int32_t vb = Float::extract_uint32_t(b);
2668 
2669  if (is_special(va) || is_special(vb)) {
2670  if (is_infinite(va) || is_infinite(vb))
2671  return va == vb; // final check is for sign bits same
2672  if (is_nan(va) || is_nan(vb))
2673  return false;
2674  }
2675 
2676  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2677  if ((va & 0x7FFFFFFF) == 0)
2678  return (vb & 0x7FFFFFFF) < close_to_zero;
2679  else if ((vb & 0x7FFFFFFF) == 0)
2680  return (va & 0x7FFFFFFF) < close_to_zero;
2681 
2682  uint32_t sign_mask = va ^ vb;
2683  (int32_t &)sign_mask >>= 31;
2684 
2685  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2686  int32_t v1 = tolerance + diff;
2687  int32_t v2 = tolerance - diff;
2688  return (v1|v2) >= 0;
2689 }
2690 
2691 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2692  int32_t va[2], vb[2];
2693  memcpy (va, &a, sizeof(double));
2694  memcpy (vb, &b, sizeof(double));
2695 
2696  if (is_special(va) || is_special(vb)) {
2697  if (is_infinite(va) || is_infinite(vb))
2698  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2699  if (is_nan(va) || is_nan(vb))
2700  return false;
2701  }
2702 
2703  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2704  return Abs(a - b) < 0.000000000000005;
2705 
2706  if (extract_sign_bit(a) != extract_sign_bit(b))
2707  return a == b; //-V550
2708 
2709  if (va[High] != vb[High])
2710  return false;
2711 
2712  return Abs(va[Low] - vb[Low]) <= tolerance;
2713 }
2714 
2716 
2717 
2718 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2719 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2720 
2721 template <typename T>
2722 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2723  while (count-- > 0)
2724  if (Is_Abnormal (*t++))
2725  return true;
2726  return false;
2727 }
2728 
2729 template <typename T>
2730 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2731  return count >= 0 && Is_Abnormal((size_t)count, t);
2732 }
2733 
2734 
2736 
2737 
2738 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2739 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2740 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2741 template <typename F> class HPS_TEMPLATE_API Point_2D;
2742 
2743 
2744 template <typename F>
2745 class HPS_TEMPLATE_API Point_3D {
2746  public:
2747  F x;
2748  F y;
2749  F z;
2750 
2751  Point_3D () {}
2752  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2753 
2754  template <typename D>
2755  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2756 
2757  explicit Point_3D (Vector_3D<F> const & v);
2758  explicit Point_3D (Vector_2D<F> const & v);
2759  explicit Point_3D (Point_2D<F> const & that);
2760 
2761  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2762 
2763  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2764  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2765 
2766  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2767  return Float::Equals(x, p.x, in_tolerance) &&
2768  Float::Equals(y, p.y, in_tolerance) &&
2769  Float::Equals(z, p.z, in_tolerance);
2770  }
2771 
2772 
2773  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2774  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2775  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2776  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2777 
2778  F & operator[] (size_t i) { return (&x)[i]; }
2779  F const & operator[] (size_t i) const { return (&x)[i]; }
2780 
2781  Point_3D & operator+= (Vector_3D<F> const & v);
2782  Point_3D & operator-= (Vector_3D<F> const & v);
2783  Point_3D & operator*= (Vector_3D<F> const & v);
2784  Point_3D & operator/= (Vector_3D<F> const & v);
2785  Point_3D const operator* (Vector_3D<F> const & v) const;
2786  Point_3D const operator/ (Vector_3D<F> const & v) const;
2787 
2788  Point_3D & operator+= (Vector_2D<F> const & v);
2789  Point_3D & operator-= (Vector_2D<F> const & v);
2790  Point_3D & operator*= (Vector_2D<F> const & v);
2791  Point_3D & operator/= (Vector_2D<F> const & v);
2792  Point_3D const operator* (Vector_2D<F> const & v) const;
2793  Point_3D const operator/ (Vector_2D<F> const & v) const;
2794 
2795  Vector_3D<F> const operator- (Point_3D const & p) const;
2796 
2797  Point_3D const operator+ (Vector_3D<F> const & v) const;
2798  Point_3D const operator- (Vector_3D<F> const & v) const;
2799 
2800  Point_3D const operator+ (Vector_2D<F> const & v) const;
2801  Point_3D const operator- (Vector_2D<F> const & v) const;
2802 
2803  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2804  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2805 };
2806 
2807 typedef Point_3D<float> Point;
2808 typedef Point_3D<double> DPoint;
2809 
2810 
2811 
2812 template <typename F, typename S>
2813 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)); }
2814 
2815 template <typename F>
2816 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2817  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2818 }
2819 
2820 template <typename F>
2821 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2822  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);
2823 }
2824 
2825 template <typename F>
2826 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2827  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2828 }
2829 
2830 
2831 template <typename F>
2832 class HPS_TEMPLATE_API Point_2D {
2833 public:
2834  F x;
2835  F y;
2836 
2837  Point_2D () {}
2838  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2839 
2840  template <typename D>
2841  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2842 
2843  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2844  explicit Point_2D (Vector_2D<F> const & v);
2845 
2846  Point_2D const operator- () const { return Point_2D (-x, -y); }
2847 
2848  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2849  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2850 
2851  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2852  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2853  }
2854 
2855 
2856  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2857  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2858  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2859  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2860 
2861  F & operator[] (size_t i) { return (&x)[i]; }
2862  F const & operator[] (size_t i) const { return (&x)[i]; }
2863 
2864  Point_2D & operator+= (Vector_2D<F> const & v);
2865  Point_2D & operator-= (Vector_2D<F> const & v);
2866  Point_2D & operator*= (Vector_2D<F> const & v);
2867  Point_2D & operator/= (Vector_2D<F> const & v);
2868  Point_2D const operator* (Vector_2D<F> const & v) const;
2869  Point_2D const operator/ (Vector_2D<F> const & v) const;
2870 
2871  Vector_2D<F> const operator- (Point_2D const & p) const;
2872 
2873  Point_2D const operator+ (Vector_2D<F> const & v) const;
2874  Point_2D const operator- (Vector_2D<F> const & v) const;
2875 
2876  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2877  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2878 };
2879 
2880 typedef Point_2D<float> Point2D;
2881 typedef Point_2D<double> DPoint2D;
2882 
2883 template <typename F>
2884 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2885 
2886 template <typename F, typename S>
2887 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)); }
2888 
2889 template <typename F>
2890 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2891  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2892 }
2893 
2894 template <typename F>
2895 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2896  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);
2897 }
2898 
2899 template <typename F>
2900 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2901  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2902 }
2903 
2904 
2905 template <typename F>
2906 class HPS_TEMPLATE_API Vector_3D {
2907  public:
2908  F x;
2909  F y;
2910  F z;
2911 
2912  Vector_3D () {}
2913  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2914  template <typename D>
2915  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2916  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2917  explicit Vector_3D(Plane_3D<F> const & p);
2918 
2919  explicit Vector_3D (Vector_2D<F> const & that);
2920 
2921  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2922 
2923  bool operator== (Vector_3D const & v) const {
2924  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2925  }
2926  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2927 
2928  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2929  return Float::Equals(x, v.x, in_tolerance) &&
2930  Float::Equals(y, v.y, in_tolerance) &&
2931  Float::Equals(z, v.z, in_tolerance);
2932  }
2933 
2934  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2935  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2936  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2937  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2938 
2939  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2940  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2941  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2942  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2943 
2944  F & operator[] (size_t i) { return (&x)[i]; }
2945  F const & operator[] (size_t i) const { return (&x)[i]; }
2946 
2947  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2948 
2949  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2950 
2951  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2952 
2953  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2954 
2955  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2956  if (check_range) {
2957  F range = Max (Abs (x), Abs (y), Abs (z));
2958  if (range > F(1.0e10))
2959  operator/= (range);
2960  }
2961 
2962  F len = (F)Length();
2963  if (len > epsilon)
2964  operator/= (len);
2965  else
2966  *this = Zero();
2967  return *this;
2968  }
2969  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2970 
2971  HPS_INLINE Vector_3D & Clean_Zeroes (F epsilon = F(1.0e-4)) {
2972  if (Abs(x) < epsilon)
2973  x = 0;
2974  if (Abs(y) < epsilon)
2975  y = 0;
2976  if (Abs(z) < epsilon)
2977  z = 0;
2978  return *this;
2979  }
2980 
2981  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2982  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2983 
2984  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2985 
2986  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2987  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2988  }
2989 
2990 
2991  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2992  return Vector_3D (x * v.x, y * v.y, z * v.z);
2993  }
2994 
2995  Vector_3D<F> different_vector () const {
2996  if (Abs (x) < Abs (y))
2997  return Vector_3D<F>::XAxis();
2998  else
2999  return Vector_3D<F>::YAxis();
3000  }
3001 
3002 
3003  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
3004  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
3005  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
3006  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
3007  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
3008 };
3009 
3010 typedef Vector_3D<float> Vector;
3011 typedef Vector_3D<double> DVector;
3012 
3013 
3014 template <typename F, typename S>
3015 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)); }
3016 
3017 template <typename F>
3018 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
3019  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
3020 }
3021 
3022 
3023 template <typename F>
3024 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
3025 
3026 template <typename F>
3027 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; }
3028 template <typename F>
3029 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; }
3030 
3031 template <typename F>
3032 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); }
3033 
3034 template <typename F>
3035 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); }
3036 template <typename F>
3037 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); }
3038 
3039 template <typename F>
3040 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; }
3041 template <typename F>
3042 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; }
3043 template <typename F>
3044 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); }
3045 template <typename F>
3046 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); }
3047 
3048 
3049 
3050 template <typename F>
3051 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
3052  return a + (b - a) * t;
3053 }
3054 
3055 template <typename F>
3056 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
3057  return Vector_3D<F>(a + (b - a) * t).Normalize();
3058 }
3059 
3060 
3061 
3062 template <typename F>
3063 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
3064  return (p2 - p1).Length();
3065 }
3066 
3067 template <typename F>
3068 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
3069  return (p2 - p1).LengthSquared();
3070 }
3071 
3072 template <typename F>
3073 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
3074  F p = static_cast<F>((c - b).LengthSquared());
3075  F q = static_cast<F>((c - a).LengthSquared());
3076  F r = static_cast<F>((b - a).LengthSquared());
3077 
3078  return Point_3D<F>(
3079  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
3080  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
3081 }
3082 
3083 
3084 
3085 template <typename F>
3086 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
3087  bool success = true;
3088  for (size_t i = 0; i < count; ++i) {
3089  if (vectors->Normalize() == Vector_3D<F>::Zero())
3090  success = false;
3091  vectors++;
3092  }
3093  return success;
3094 }
3095 
3096 
3097 template <typename F> class HPS_TEMPLATE_API Plane_2D;
3098 
3099 template <typename F>
3100 class HPS_TEMPLATE_API Vector_2D {
3101 public:
3102  F x;
3103  F y;
3104 
3105  Vector_2D () {}
3106  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
3107  template <typename D>
3108  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
3109 
3110  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
3111  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
3112  explicit Vector_2D (Plane_2D<F> const & p);
3113 
3114  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
3115 
3116  bool operator== (Vector_2D const & v) const {
3117  return Float::match(x, v.x) && Float::match(y, v.y);
3118  }
3119  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
3120 
3121  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
3122  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
3123  }
3124 
3125  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
3126  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
3127  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
3128  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
3129 
3130  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
3131  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
3132  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
3133  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
3134 
3135  F & operator[] (size_t i) { return (&x)[i]; }
3136  F const & operator[] (size_t i) const { return (&x)[i]; }
3137 
3138  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
3139 
3140  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
3141 
3142  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
3143  if (check_range) {
3144  F range = Max (Abs (x), Abs (y));
3145  if (range > F(1.0e10))
3146  operator/= (range);
3147  }
3148 
3149  F len = (F)Length();
3150  if (len > epsilon)
3151  operator/= (len);
3152  else
3153  *this = Zero();
3154  return *this;
3155  }
3156  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
3157 
3158  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
3159  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
3160 
3161  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
3162 
3163 
3164  HPS_INLINE F Cross (Vector_2D const & v) const {
3165  return x * v.y - y * v.x;
3166  }
3167 
3168  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
3169  return Vector_2D (x * v.x, y * v.y);
3170  }
3171 
3172  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
3173  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
3174 
3175  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
3176  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
3177 };
3178 
3179 typedef Vector_2D<float> Vector2D;
3181 
3182 template <typename F, typename S>
3183 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)); }
3184 
3185 template <typename F>
3186 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
3187  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
3188 }
3189 
3190 
3191 template <typename F>
3192 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
3193 
3194 template <typename F>
3195 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
3196 
3197 template <typename F>
3198 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3199 template <typename F>
3200 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3201 
3202 template <typename F>
3203 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); }
3204 template <typename F>
3205 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); }
3206 
3207 template <typename F>
3208 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3209 template <typename F>
3210 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3211 
3212 template <typename F>
3213 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); }
3214 template <typename F>
3215 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); }
3216 
3217 
3218 template <typename F>
3219 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3220 template <typename F>
3221 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3222 
3223 template <typename F>
3224 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); }
3225 
3226 template <typename F>
3227 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); }
3228 template <typename F>
3229 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); }
3230 
3231 template <typename F>
3232 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3233 template <typename F>
3234 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3235 template <typename F>
3236 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); }
3237 template <typename F>
3238 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); }
3239 
3240 
3241 
3242 
3243 
3244 template <typename F>
3245 class HPS_TEMPLATE_API Plane_3D {
3246  public:
3247  F a;
3248  F b;
3249  F c;
3250  F d;
3251 
3252  Plane_3D () {}
3253  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3254  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3255  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)) {}
3256  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)) {}
3257  template <typename D>
3258  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3259 
3260  Plane_3D (size_t count, Point_3D<F> const * points) {
3261  if (count >= 3) {
3262  // The 3 coefficients A, B, and C are proportional to the areas of the
3263  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3264 
3265  // run around the polygon, collecting trapezoidal areas
3266  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3267 
3268  // take care of the swing point first
3269  Point_3D<F> const * p0 = &points[count-1];
3270 
3272  Vector_3D<F> normal = Vector_3D<F>::Zero();
3273 
3274  for (size_t i=0; i<count; ++i) {
3275  Point_3D<F> const * p1 = &points[i];
3276 
3277  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3278  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3279  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3280 
3281  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3282 
3283  p0 = p1;
3284  }
3285 
3286  // ("should" always be != 0)
3287  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3288  /* finish finding the average */
3289  double inv_count = 1.0 / (double)count;
3290  ctr *= inv_count;
3291 
3292  *this = Plane_3D(normal, Point_3D<F>(ctr));
3293  return;
3294  }
3295  }
3296 
3297  *this = Plane_3D::Zero();
3298  }
3299 
3300 
3301  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3302 
3303  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3304  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3305 
3306  F & operator[] (size_t i) { return (&a)[i]; }
3307  F const & operator[] (size_t i) const { return (&a)[i]; }
3308 
3309  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3310  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3311  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3312  }
3313 
3314  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3315  F len = (F)Vector_3D<F>(*this).Length();
3316  if (len > epsilon)
3317  operator/= (len);
3318  else
3319  *this = Zero();
3320  return *this;
3321  }
3322 
3323  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3324  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3325  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3326 
3327  if (val1 >= eps) {
3328  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3329  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3330  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3331  }
3332  else
3333  return p1;
3334  }
3335 
3336  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3337  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3338  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3339 
3340  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));
3341  }
3342 
3343 
3344  bool parallel (Plane_3D const & p) const {
3345  return equivalent (a, p.a) &&
3346  equivalent (b, p.b) &&
3347  equivalent (c, p.c);
3348  }
3349 
3350  bool equivalent (Plane_3D const & p) const {
3351  return parallel (p) &&
3352  equivalent (d, p.d, (F)1.0e-6);
3353  }
3354 
3355 
3356  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3357 
3358 
3359  private:
3360  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3361  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3362  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3363  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3364 
3365  static bool equivalent (float a, float b) { // for vector components
3366  if (Abs(a) < 1.0e-4f && Abs(b) < 1.0e-4f)
3367  return true;
3368  return Float::Equals (a, b);
3369  }
3370 
3371  static bool equivalent (float a, float b, float cutoff) { // for distance
3372  if (Abs(a) < cutoff && Abs(b) < cutoff)
3373  return a == b;
3374  return Float::Equals (a, b);
3375  }
3376 };
3377 
3378 typedef Plane_3D<float> Plane;
3379 typedef Plane_3D<double> DPlane;
3380 
3381 
3382 template <typename F>
3383 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3384  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3385 }
3386 
3387 
3388 template <typename F>
3389 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3390  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3391 }
3392 template <typename F>
3393 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3394  return plane * point;
3395 }
3396 
3397 template <typename F>
3398 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3399  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);
3400 }
3401 
3402 template <typename F>
3403 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3404 
3405 
3406 
3407 
3408 
3409 
3410 template <typename F>
3411 class HPS_TEMPLATE_API Plane_2D {
3412 public:
3413  F a;
3414  F b;
3415  F c;
3416 
3417  Plane_2D () {}
3418  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3419  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3420  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)) {}
3421  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)) {}
3422  template <typename D>
3423  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3424 
3425  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3426 
3427  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3428  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3429 
3430  F & operator[] (size_t i) { return (&a)[i]; }
3431  F const & operator[] (size_t i) const { return (&a)[i]; }
3432 
3433  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3434  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3435  }
3436 
3437  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3438  F len = (F)Vector_2D<F>(*this).Length();
3439  if (len > epsilon)
3440  operator/= (len);
3441  else
3442  *this = Zero();
3443  return *this;
3444  }
3445 
3446  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3447 
3448 
3449 private:
3450  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3451  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3452  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3453  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3454 };
3455 
3456 typedef Plane_2D<float> Plane2D;
3457 typedef Plane_2D<double> DPlane2D;
3458 
3459 
3460 template <typename F>
3461 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3462  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3463 }
3464 
3465 
3466 template <typename F>
3467 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3468  return plane.a * point.x + plane.b * point.y + plane.c;
3469 }
3470 template <typename F>
3471 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3472  return plane * point;
3473 }
3474 
3475 template <typename F>
3476 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3477  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);
3478 }
3479 
3480 template <typename F>
3481 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3482 
3483 
3484 
3485 
3486 struct Rectangle;
3487 
3488 struct HPS_API IntRectangle {
3489  int left;
3490  int right;
3491  int bottom;
3492  int top;
3493 
3494  IntRectangle()
3495  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3496  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3497 
3498  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3499  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3500 
3501  IntRectangle(IntRectangle const & that)
3502  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3503 
3504  explicit IntRectangle(Rectangle const & that);
3505 
3506  bool operator==(IntRectangle const & rect) const {
3507  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3508  }
3509 
3510  bool operator!=(IntRectangle const & rect) const {
3511  return !(*this == rect);
3512  }
3513 
3514  HPS_INLINE int PixelWidth() const {
3515  return right - left + 1;
3516  }
3517 
3518  HPS_INLINE int PixelHeight() const {
3519  return top - bottom + 1;
3520  }
3521 
3522  HPS_INLINE int Width() const {
3523  return right - left;
3524  }
3525 
3526  HPS_INLINE int Height() const {
3527  return top - bottom;
3528  }
3529 
3530  HPS_INLINE int Area() const {
3531  return Width() * Height();
3532  }
3533 
3534  HPS_INLINE float Aspect() const {
3535  return (float)Height() / (float)Width();
3536  }
3537 
3538  HPS_INLINE Point2D Center() const {
3539  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3540  }
3541 
3542  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3543  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3544  }
3545 
3546  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3547  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3548  }
3549 
3550  HPS_INLINE IntRectangle & Expand(int border) {
3551  left -= border;
3552  right += border;
3553  bottom -= border;
3554  top += border;
3555  return *this;
3556  }
3557 
3558  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3559  left -= rect.left;
3560  right += rect.right;
3561  bottom -= rect.bottom;
3562  top += rect.top;
3563  return *this;
3564  }
3565 
3566  HPS_INLINE IntRectangle & Contract(int border) {
3567  left += border;
3568  right -= border;
3569  bottom += border;
3570  top -= border;
3571  return *this;
3572  }
3573 
3574  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3575  left += rect.left;
3576  right -= rect.right;
3577  bottom += rect.bottom;
3578  top -= rect.top;
3579  return *this;
3580  }
3581 
3582  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3583  left = Max(left, rect.left);
3584  right = Min(right, rect.right);
3585  bottom = Max(bottom, rect.bottom);
3586  top = Min(top, rect.top);
3587  return *this;
3588  }
3589 
3590  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3591  left = Min(left, rect.left);
3592  right = Max(right, rect.right);
3593  bottom = Min(bottom, rect.bottom);
3594  top = Max(top, rect.top);
3595  return *this;
3596  }
3597 
3598 
3599  static HPS_INLINE IntRectangle Invalid() {
3600  return IntRectangle();
3601  }
3602 
3603  static HPS_INLINE IntRectangle Zero() {
3604  return IntRectangle(0, 0, 0, 0);
3605  }
3606 
3607 };
3608 
3609 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3610  IntRectangle temp = a;
3611  return temp.Expand(border);
3612 }
3613 
3614 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3615  IntRectangle temp = a;
3616  return temp.Expand(border);
3617 }
3618 
3619 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3620  IntRectangle temp = a;
3621  return temp.Contract(border);
3622 }
3623 
3624 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3625  IntRectangle temp = a;
3626  return temp.Contract(border);
3627 }
3628 
3629 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3630  IntRectangle temp = a;
3631  return temp.Intersect(b);
3632 }
3633 
3634 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3635  IntRectangle temp = a;
3636  return temp.Union(b);
3637 }
3638 
3639 struct HPS_API Rectangle {
3640  float left;
3641  float right;
3642  float bottom;
3643  float top;
3644 
3645  Rectangle()
3646  : left(std::numeric_limits<float>::max()), right(-std::numeric_limits<float>::max()),
3647  bottom(std::numeric_limits<float>::max()), top(-std::numeric_limits<float>::max()) {}
3648 
3649  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3650  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3651 
3652  Rectangle(Rectangle const & that)
3653  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3654 
3655  explicit Rectangle(IntRectangle const & that)
3656  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3657 
3658  HPS_INLINE Rectangle(size_t count, Point const * points) {
3659  left = points->x;
3660  right = points->x;
3661  top = points->y;
3662  bottom = points->y;
3663  --count;
3664  if (count > 0) {
3665  ++points;
3666  Merge(count, points);
3667  }
3668  }
3669 
3670  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3671  left = points->x;
3672  right = points->x;
3673  top = points->y;
3674  bottom = points->y;
3675  --count;
3676  if (count > 0) {
3677  ++points;
3678  Merge(count, points);
3679  }
3680  }
3681 
3682  HPS_INLINE float Width() const {
3683  return right - left;
3684  }
3685 
3686  HPS_INLINE float Height() const {
3687  return top - bottom;
3688  }
3689 
3690  HPS_INLINE float Area() const {
3691  return Width() * Height();
3692  }
3693 
3694  HPS_INLINE float Aspect() const {
3695  return Height() / Width();
3696  }
3697 
3698  HPS_INLINE Point2D Center() const {
3699  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3700  }
3701 
3702  HPS_INLINE void Merge(size_t count, Point const * points) {
3703 
3704  while (count > 1) {
3705  if (points[0].x > points[1].x) {
3706  Float::replace_if_smaller(left, points[1].x);
3707  Float::replace_if_larger(right, points[0].x);
3708  }
3709  else {
3710  Float::replace_if_smaller(left, points[0].x);
3711  Float::replace_if_larger(right, points[1].x);
3712  }
3713 
3714  if (points[0].y > points[1].y) {
3715  Float::replace_if_smaller(bottom, points[1].y);
3716  Float::replace_if_larger(top, points[0].y);
3717  }
3718  else {
3719  Float::replace_if_smaller(bottom, points[0].y);
3720  Float::replace_if_larger(top, points[1].y);
3721  }
3722 
3723  points += 2;
3724  count -= 2;
3725  }
3726 
3727  if (count > 0)
3728  Merge(*points);
3729  }
3730 
3731  HPS_INLINE void Merge(Point const & point) {
3732  Float::replace_if_smaller(left, point.x);
3733  Float::replace_if_smaller(bottom, point.y);
3734  Float::replace_if_larger(right, point.x);
3735  Float::replace_if_larger(top, point.y);
3736  }
3737 
3738  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3739 
3740  while (count > 1) {
3741  if (points[0].x > points[1].x) {
3742  Float::replace_if_smaller(left, points[1].x);
3743  Float::replace_if_larger(right, points[0].x);
3744  }
3745  else {
3746  Float::replace_if_smaller(left, points[0].x);
3747  Float::replace_if_larger(right, points[1].x);
3748  }
3749 
3750  if (points[0].y > points[1].y) {
3751  Float::replace_if_smaller(bottom, points[1].y);
3752  Float::replace_if_larger(top, points[0].y);
3753  }
3754  else {
3755  Float::replace_if_smaller(bottom, points[0].y);
3756  Float::replace_if_larger(top, points[1].y);
3757  }
3758 
3759  points += 2;
3760  count -= 2;
3761  }
3762 
3763  if (count > 0)
3764  Merge(*points);
3765  }
3766 
3767  HPS_INLINE void Merge(Point2D const & point) {
3768  Float::replace_if_smaller(left, point.x);
3769  Float::replace_if_smaller(bottom, point.y);
3770  Float::replace_if_larger(right, point.x);
3771  Float::replace_if_larger(top, point.y);
3772  }
3773 
3774  HPS_INLINE bool operator==(Rectangle const & rect) const {
3775  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3776  }
3777 
3778  HPS_INLINE bool operator!=(Rectangle const & rect) const {
3779  return !(*this == rect);
3780  }
3781 
3782  HPS_INLINE bool Equals(Rectangle const & rect, int in_tolerance = 32) const {
3783  return Float::Equals(left, rect.left, in_tolerance) &&
3784  Float::Equals(right, rect.right, in_tolerance) &&
3785  Float::Equals(top, rect.top, in_tolerance) &&
3786  Float::Equals(bottom, rect.bottom, in_tolerance);
3787  }
3788 
3789  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3790  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3791  }
3792 
3793  HPS_INLINE bool Contains(Point const & contained) const {
3794  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3795  }
3796 
3797  HPS_INLINE bool Contains(Point2D const & contained) const {
3798  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3799  }
3800 
3801  HPS_INLINE bool Contains(Rectangle const & rect) {
3802  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3803  }
3804 
3805  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3806  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3807  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3808  }
3809 
3810  HPS_INLINE Rectangle & Expand(float border) {
3811  left -= border;
3812  right += border;
3813  bottom -= border;
3814  top += border;
3815  return *this;
3816  }
3817 
3818  HPS_INLINE Rectangle & Expand(int border) {
3819  Expand((float)border);
3820  return *this;
3821  }
3822 
3823  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3824  left -= rect.left;
3825  right += rect.right;
3826  bottom -= rect.bottom;
3827  top += rect.top;
3828  return *this;
3829  }
3830 
3831  HPS_INLINE Rectangle & Contract(int border) {
3832  left += border;
3833  right -= border;
3834  bottom += border;
3835  top -= border;
3836  return *this;
3837  }
3838 
3839  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3840  left += rect.left;
3841  right -= rect.right;
3842  bottom += rect.bottom;
3843  top -= rect.top;
3844  return *this;
3845  }
3846 
3847  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3848  left = Max(left, rect.left);
3849  right = Min(right, rect.right);
3850  bottom = Max(bottom, rect.bottom);
3851  top = Min(top, rect.top);
3852  return *this;
3853  }
3854 
3855  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3856  left = Min(left, rect.left);
3857  right = Max(right, rect.right);
3858  bottom = Min(bottom, rect.bottom);
3859  top = Max(top, rect.top);
3860  return *this;
3861  }
3862 
3863  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3864  float scale = (scope.right - scope.left) * 0.5f;
3865  float trans = (scope.right + scope.left) * 0.5f;
3866 
3867  left = left * scale + trans;
3868  right = right * scale + trans;
3869 
3870  scale = (scope.top - scope.bottom) * 0.5f;
3871  trans = (scope.top + scope.bottom) * 0.5f;
3872 
3873  bottom = bottom * scale + trans;
3874  top = top * scale + trans;
3875  return *this;
3876  }
3877 
3878  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3879  float tmp = 2.0f/(scope.right - scope.left);
3880  right = (right - scope.left) * tmp - 1.0f;
3881  left = (left - scope.left) * tmp - 1.0f;
3882 
3883  tmp = 2.0f/(scope.top - scope.bottom);
3884  top = (top - scope.bottom) * tmp - 1.0f;
3885  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3886  return *this;
3887  }
3888 
3889  static HPS_INLINE Rectangle FullScope() {
3890  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3891  }
3892 
3893  static HPS_INLINE Rectangle InvalidScope() {
3894  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3895  }
3896 
3897  static HPS_INLINE Rectangle Zero() {
3898  return Rectangle(0, 0, 0, 0);
3899  }
3900 
3901 };
3902 
3903 
3904 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3905  IntRectangle temp;
3906  temp.left = Floor (a.left);
3907  temp.right = Floor (a.right);
3908  temp.bottom = Floor (a.bottom);
3909  temp.top = Floor (a.top);
3910  return temp;
3911 }
3912 
3913 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3914  Rectangle temp = a;
3915  return temp.Expand(border);
3916 }
3917 
3918 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3919  Rectangle temp = a;
3920  return temp.Expand(border);
3921 }
3922 
3923 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3924  Rectangle temp = a;
3925  return temp.Contract(border);
3926 }
3927 
3928 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3929  Rectangle temp = a;
3930  return temp.Contract(border);
3931 }
3932 
3933 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3934  Rectangle temp = a;
3935  return temp.Intersect(b);
3936 }
3937 
3938 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3939  Rectangle temp = a;
3940  return temp.Union(b);
3941 }
3942 
3943 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3944  Rectangle temp = a;
3945  return temp.Inscribe_Scope(scope);
3946 }
3947 
3948 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3949  Rectangle temp = a;
3950  return temp.Circumscribe_Scope(scope);
3951 }
3952 
3953 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3954  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3955 
3956 
3957 
3958 
3959 template <typename F>
3960 struct Sphere_3D;
3961 
3962 template <typename F>
3963 struct HPS_TEMPLATE_API Cuboid_3D {
3968 
3969 
3973  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3974 
3975 
3980  template <typename D>
3981  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3982 
3983 
3988  Cuboid_3D (Sphere_3D<F> const & that);
3989 
3995  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3996 
4002  Cuboid_3D (size_t count, Point_3D<F> const * points) {
4003  if (count == 0) {
4004  min = Limit_Point();
4005  max = -Limit_Point();
4006  return;
4007  }
4008  min = max = *points++;
4009  if (--count > 0)
4010  Merge(count, points);
4011  }
4012 
4019  template <typename T>
4020  Cuboid_3D (size_t count, T const * indices, Point_3D<F> const * points) {
4021  if (count == 0) {
4022  min = Limit_Point();
4023  max = -Limit_Point();
4024  return;
4025  }
4026  min = max = points[*indices++];
4027  if (--count > 0)
4028  Merge(count, indices, points);
4029  }
4030 
4035  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
4036 
4040  HPS_INLINE bool IsValid() const {
4041  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
4042  }
4043 
4047  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
4048 
4052  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
4053 
4058  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
4059 
4064  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
4065 
4070  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
4071  points[0] = Point_3D<F> (min.x, min.y, min.z);
4072  points[1] = Point_3D<F> (min.x, min.y, max.z);
4073  points[2] = Point_3D<F> (min.x, max.y, min.z);
4074  points[3] = Point_3D<F> (min.x, max.y, max.z);
4075  points[4] = Point_3D<F> (max.x, min.y, min.z);
4076  points[5] = Point_3D<F> (max.x, min.y, max.z);
4077  points[6] = Point_3D<F> (max.x, max.y, min.z);
4078  points[7] = Point_3D<F> (max.x, max.y, max.z);
4079  }
4080 
4084  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
4085 
4089  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
4090 
4096  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
4097  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
4098  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
4099  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
4100  }
4101 
4107  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
4108  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
4109  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
4110  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
4111  }
4112 
4119  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
4120  //ASSERT (0 <= dimension && dimension <= 2);
4121  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
4122  }
4123 
4131  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
4132  //ASSERT (0 <= dimension && dimension <= 2);
4133  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
4134  }
4135 
4142  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
4143  return LineIntersecting(start, direction, true);
4144  }
4145 
4152  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
4153  Vector_3D<F> const direction = point2 - point1;
4154  return LineIntersecting(point1, direction, false);
4155  }
4156 
4162  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
4163  Float::replace_if_smaller(min.x, cuboid.min.x);
4164  Float::replace_if_smaller(min.y, cuboid.min.y);
4165  Float::replace_if_smaller(min.z, cuboid.min.z);
4166  Float::replace_if_larger(max.x, cuboid.max.x);
4167  Float::replace_if_larger(max.y, cuboid.max.y);
4168  Float::replace_if_larger(max.z, cuboid.max.z);
4169  }
4170 
4176  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
4177 
4183  HPS_INLINE void Merge(Point_3D<F> const & point) {
4184  Float::replace_if_smaller(min.x, point.x);
4185  Float::replace_if_smaller(min.y, point.y);
4186  Float::replace_if_smaller(min.z, point.z);
4187  Float::replace_if_larger(max.x, point.x);
4188  Float::replace_if_larger(max.y, point.y);
4189  Float::replace_if_larger(max.z, point.z);
4190  }
4191 
4198  void Merge(size_t count, Point_3D<F> const * points) {
4199  while (count > 1) {
4200  merge2(points[0], points[1]);
4201  points += 2;
4202  count -= 2;
4203  }
4204 
4205  if (count > 0)
4206  Merge(*points);
4207  }
4208 
4216  template <typename T>
4217  void Merge(size_t count, T const * indices, Point_3D<F> const * points) {
4218  while (count > 1) {
4219  T i1 = *indices++;
4220  T i2 = *indices++;
4221  merge2(points[i1], points[i2]);
4222  count -= 2;
4223  }
4224 
4225  if (count > 0)
4226  Merge(points[*indices]);
4227  }
4228 
4234  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
4235  return (contained.min.x >= min.x &&
4236  contained.min.y >= min.y &&
4237  contained.min.z >= min.z &&
4238  contained.max.x <= max.x &&
4239  contained.max.y <= max.y &&
4240  contained.max.z <= max.z);
4241  }
4242 
4248  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
4249  return (contained.x >= min.x &&
4250  contained.y >= min.y &&
4251  contained.z >= min.z &&
4252  contained.x <= max.x &&
4253  contained.y <= max.y &&
4254  contained.z <= max.z);
4255  }
4256 
4263  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4264  return (contained.x >= min.x - epsilon &&
4265  contained.y >= min.y - epsilon &&
4266  contained.z >= min.z - epsilon &&
4267  contained.x <= max.x + epsilon &&
4268  contained.y <= max.y + epsilon &&
4269  contained.z <= max.z + epsilon);
4270  }
4271 
4277  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4278  Float::replace_if_larger(min.x, cuboid.min.x);
4279  Float::replace_if_larger(min.y, cuboid.min.y);
4280  Float::replace_if_larger(min.z, cuboid.min.z);
4281  Float::replace_if_smaller(max.x, cuboid.max.x);
4282  Float::replace_if_smaller(max.y, cuboid.max.y);
4283  Float::replace_if_smaller(max.z, cuboid.max.z);
4284  return *this;
4285  }
4286 
4292  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4293  Float::replace_if_smaller(min.x, cuboid.min.x);
4294  Float::replace_if_smaller(min.y, cuboid.min.y);
4295  Float::replace_if_smaller(min.z, cuboid.min.z);
4296  Float::replace_if_larger(max.x, cuboid.max.x);
4297  Float::replace_if_larger(max.y, cuboid.max.y);
4298  Float::replace_if_larger(max.z, cuboid.max.z);
4299  return *this;
4300  }
4301 
4307  HPS_INLINE Cuboid_3D & Expand(F border) {
4308  Vector_3D<F> delta (border, border, border);
4309  min -= delta;
4310  max += delta;
4311  return *this;
4312  }
4313 
4319  HPS_INLINE Cuboid_3D & Contract(F border) {
4320  Vector_3D<F> delta (border, border, border);
4321  min += delta;
4322  max -= delta;
4323  return *this;
4324  }
4325 
4326 private:
4327  void merge2(Point_3D<F> const & p1, Point_3D<F> const & p2) {
4328  if (p1.x > p2.x) {
4329  Float::replace_if_smaller(min.x, p2.x);
4330  Float::replace_if_larger(max.x, p1.x);
4331  }
4332  else {
4333  Float::replace_if_smaller(min.x, p1.x);
4334  Float::replace_if_larger(max.x, p2.x);
4335  }
4336 
4337  if (p1.y > p2.y) {
4338  Float::replace_if_smaller(min.y, p2.y);
4339  Float::replace_if_larger(max.y, p1.y);
4340  }
4341  else {
4342  Float::replace_if_smaller(min.y, p1.y);
4343  Float::replace_if_larger(max.y, p2.y);
4344  }
4345 
4346  if (p1.z > p2.z) {
4347  Float::replace_if_smaller(min.z, p2.z);
4348  Float::replace_if_larger(max.z, p1.z);
4349  }
4350  else {
4351  Float::replace_if_smaller(min.z, p1.z);
4352  Float::replace_if_larger(max.z, p2.z);
4353  }
4354  }
4355 
4356  HPS_INLINE static Point_3D<F> Limit_Point () {
4357  F const x = std::numeric_limits<F>::max();
4358  return Point_3D<F> (x, x, x);
4359  }
4360 
4361  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4362 };
4363 
4364 typedef Cuboid_3D<float> SimpleCuboid;
4365 typedef Cuboid_3D<double> DSimpleCuboid;
4366 
4367 
4368 template <typename F>
4369 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4370  Cuboid_3D<F> temp = a;
4371  return temp.Intersect(b);
4372 }
4373 
4374 template <typename F>
4375 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4376  Cuboid_3D<F> temp = a;
4377  return temp.Union(b);
4378 }
4379 
4380 template <typename F>
4381 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4382  Cuboid_3D<F> temp = a;
4383  return temp.Expand(border);
4384 }
4385 
4386 template <typename F>
4387 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4388  Cuboid_3D<F> temp = a;
4389  return temp.Contract(border);
4390 }
4391 
4392 
4393 
4394 template <typename F>
4395 struct HPS_TEMPLATE_API Sphere_3D {
4396  Point_3D<F> center;
4397  F radius;
4398 
4399  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(-1) {}
4400 
4401  template <typename D>
4402  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4403 
4404  Sphere_3D (Cuboid_3D<F> const & cuboid) {
4405  if (cuboid.max.x < cuboid.min.x || cuboid.max.y < cuboid.min.y || cuboid.max.z < cuboid.min.z)
4406  *this = Invalid();
4407  else {
4408  center = Midpoint(cuboid.min, cuboid.max);
4409  radius = F(0.5 * cuboid.Diagonal().Length());
4410  }
4411  }
4412 
4413  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4414 
4415  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4416  Cuboid_3D<F> cuboid(count, points);
4417  center = Midpoint(cuboid.min, cuboid.max);
4418  Engulf (count, points);
4419  }
4420 
4421  template <typename T>
4422  Sphere_3D (size_t count, T const * indices, Point_3D<F> const * points) : radius(0.0f) {
4423  Cuboid_3D<F> cuboid(count, indices, points);
4424  center = Midpoint(cuboid.min, cuboid.max);
4425  Engulf (count, indices, points);
4426  }
4427 
4428  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center)
4429  : center(starting_center), radius(0) {
4430  Engulf (count, points);
4431  }
4432 
4433  template <typename T>
4434  Sphere_3D (size_t count, T const * indices, Point_3D<F> const * points, Point_3D<F> const & starting_center)
4435  : center(starting_center), radius(0) {
4436  Engulf (count, indices, points);
4437  }
4438 
4439  HPS_INLINE bool IsValid() const {
4440  return radius >= 0;
4441  }
4442 
4443  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4444 
4445  void Invalidate() {radius = -1;}
4446 
4447  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4448  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4449 
4450  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4451 
4452  HPS_INLINE void Merge(Point_3D<F> const & point) {
4453  Vector_3D<F> dir = point - center;
4454  F distance = (F)dir.Length();
4455 
4456  if (distance > radius) {
4457  F t = F(0.5) * (distance - radius);
4458  center += t * dir.Normalize();
4459  radius += t;
4460  }
4461  }
4462 
4463  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4464  F radius_squared = radius * radius;
4465  for (size_t i = 0; i < count; ++i) {
4466  Vector_3D<F> dir = *points - center;
4467  F distance_squared = (F)dir.LengthSquared();
4468 
4469  if (distance_squared > radius_squared) {
4470  F distance = sqrt(distance_squared);
4471  F t = F(0.5) * ( distance - radius);
4472  center += t * (distance > Float_Traits<F>::Epsilon() ? dir / distance : Vector_3D<F>::Zero());
4473  radius += t;
4474  radius_squared = radius * radius;
4475  }
4476 
4477  ++points;
4478  }
4479  }
4480 
4481  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4482  Vector_3D<F> dir = sphere.center - center;
4483  F distance = (F)dir.Length();
4484 
4485  if (distance + sphere.radius > radius) {
4486  if (distance + radius > sphere.radius) {
4487  F t = F(0.5 * (sphere.radius + distance - radius));
4488  center += t * dir.Normalize();
4489  radius += t;
4490  }
4491  else {
4492  center = sphere.center;
4493  radius = sphere.radius;
4494  }
4495  }
4496  }
4497 
4498  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4499 
4500 private:
4501  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4502  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4503  double rsq = radius * radius;
4504  for (size_t i = 0; i < count; ++i) {
4505  double dsq = (*points++ - center).LengthSquared();
4506  if (dsq > rsq)
4507  rsq = dsq;
4508  }
4509  radius = (F)sqrt(rsq);
4510  }
4511 
4512  template <typename T>
4513  HPS_INLINE void Engulf (size_t count, T const * indices, Point_3D<F> const * points) {
4514  double rsq = radius * radius;
4515  for (size_t i = 0; i < count; ++i) {
4516  double dsq = (points[*indices++] - center).LengthSquared();
4517  if (dsq > rsq)
4518  rsq = dsq;
4519  }
4520  radius = (F)sqrt(rsq);
4521  }
4522 };
4523 
4524 typedef Sphere_3D<float> SimpleSphere;
4525 typedef Sphere_3D<double> DSimpleSphere;
4526 
4527 
4528 template <typename F>
4529 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4530  if (sphere.radius < 0)
4531  *this = Invalid();
4532  else {
4533  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4534  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4535  }
4536 }
4537 
4538 
4539 
4540 
4541 class RGB24Color;
4542 class RGBA32Color;
4543 class RGBAS32Color;
4544 class RGBAColor;
4545 
4546 class HPS_API RGBColor {
4547 public:
4548  float red;
4549  float green;
4550  float blue;
4551 
4552  HPS_INLINE RGBColor () {}
4553  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4554  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4555  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4556  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4557  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4558  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4559 
4560  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4561  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4562  float Distance(RGBColor const & other_color) const;
4563  HPS_INLINE bool IsValid() const {
4564  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4565  }
4566 
4567  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4568  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4569 
4570  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4571  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4572 
4573  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4574  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4575  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4576  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4577  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4578  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4579 
4580  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4581  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4582  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4583  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4584  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4585  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4586  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4587  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4588 
4589  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4590  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4591  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4592 
4593  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4594  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4595  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4596 
4597  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4598  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4599  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4600 };
4601 
4602 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4603 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4604 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4605 
4606 
4607 class HPS_API RGBAColor {
4608 public:
4609 
4610  float red;
4611  float green;
4612  float blue;
4613  float alpha;
4615  HPS_INLINE RGBAColor () {}
4616  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4617  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4618 
4619  HPS_INLINE RGBAColor (RGBColor const & c) {
4620  memcpy(this, &c, sizeof(RGBColor)); //-V512
4621  alpha = 1.0f;
4622  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4623  }
4624  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4625  memcpy(this, &c, sizeof(RGBColor));
4626  memcpy(&alpha, &a, sizeof(float));
4627  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4628  }
4629  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4630  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4631 
4632  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4633  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4634  HPS_INLINE bool IsValid() const {
4635  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4636  }
4637 
4644  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4645 
4652  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4653 
4654  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4655  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4656  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4657  }
4658 
4659  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4660  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4661  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4662  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4663  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4664  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4665 
4666  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4667  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4668  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4669  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4670  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4671  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4672  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4673  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4674 
4675  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4676  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4677  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4678  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4679  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4680  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4681 
4682  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4683  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4684  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4685  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4686 };
4687 
4688 HPS_INLINE RGBAColor const operator* (float s, RGBAColor const & v) { return RGBAColor (s * v.red, s * v.green, s * v.blue, s * v.alpha); }
4689 HPS_INLINE RGBAColor const operator+ (float s, RGBAColor const & v) { return RGBAColor (s + v.red, s + v.green, s + v.blue, s + v.alpha); }
4690 HPS_INLINE RGBAColor const operator- (float s, RGBAColor const & v) { return RGBAColor (s - v.red, s - v.green, s - v.blue, s - v.alpha); }
4691 
4692 
4693 
4695 public:
4696  enum Order {
4697  Order_ABGR,
4698  Order_RGBA,
4699  Order_BGRA
4700  };
4701 
4702 #ifdef _MSC_VER
4703  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4704  unsigned char b, g, r, a;
4705 #endif
4706 
4707 #ifdef __linux__
4708  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4709  unsigned char r, g, b, a;
4710 #endif
4711 
4712 #ifdef __APPLE_CC__
4713  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4714  unsigned char r, g, b, a;
4715 #endif
4716 };
4717 
4718 
4719 
4721 public:
4722 
4723  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4724  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4725  r = gray;
4726  g = gray;
4727  b = gray;
4728  a = aa;
4729  }
4730  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4731  r = rr;
4732  g = gg;
4733  b = bb;
4734  a = aa;
4735  }
4736  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4737 
4738  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4739  {
4740  r = Float::unit_to_byte(c.red);
4741  g = Float::unit_to_byte(c.green);
4742  b = Float::unit_to_byte(c.blue);
4743  a = 255;
4744  }
4745 
4746  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4747 
4748  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4749 
4750  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4751  {
4752  r = Float::unit_to_byte(c.red);
4753  g = Float::unit_to_byte(c.green);
4754  b = Float::unit_to_byte(c.blue);
4755  a = Float::unit_to_byte(alpha);
4756  }
4757  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4758  {
4759  r = Float::unit_to_byte(c.red);
4760  g = Float::unit_to_byte(c.green);
4761  b = Float::unit_to_byte(c.blue);
4762  a = aa;
4763  }
4764  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4765  {
4766  r = Float::unit_to_byte(c.red);
4767  g = Float::unit_to_byte(c.green);
4768  b = Float::unit_to_byte(c.blue);
4769  a = Float::unit_to_byte(c.alpha);
4770  }
4771  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4772  {
4773  r = Float::unit_to_byte(c.red);
4774  g = Float::unit_to_byte(c.green);
4775  b = Float::unit_to_byte(c.blue);
4776  a = Float::unit_to_byte_scaled(c.alpha, mix);
4777  }
4778 
4779  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4780  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4781  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4782 
4783  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4784  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4785 
4786  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4787  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4788  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4789 
4790  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4791 };
4792 
4794 public:
4795  unsigned char r;
4796  unsigned char g;
4797  unsigned char b;
4798  unsigned char a;
4799 
4800  HPS_INLINE RGBA32Color () {}
4801  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4802  : r (gray), g (gray), b (gray), a (aa) {}
4803  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4804  : r (rr), g (gg), b (bb), a (aa) {}
4805  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4806  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4807  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4808  r = Float::unit_to_byte(c.red);
4809  g = Float::unit_to_byte(c.green);
4810  b = Float::unit_to_byte(c.blue);
4811  a = 255;
4812  }
4813  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4814  r = Float::unit_to_byte(c.red);
4815  g = Float::unit_to_byte(c.green);
4816  b = Float::unit_to_byte(c.blue);
4817  a = Float::unit_to_byte(alpha);
4818  }
4819  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4820  r = Float::unit_to_byte(c.red);
4821  g = Float::unit_to_byte(c.green);
4822  b = Float::unit_to_byte(c.blue);
4823  a = aa;
4824  }
4825  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4826  r = Float::unit_to_byte(c.red);
4827  g = Float::unit_to_byte(c.green);
4828  b = Float::unit_to_byte(c.blue);
4829  a = Float::unit_to_byte(c.alpha);
4830  }
4831  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4832  r = Float::unit_to_byte(c.red);
4833  g = Float::unit_to_byte(c.green);
4834  b = Float::unit_to_byte(c.blue);
4835  a = Float::unit_to_byte_scaled(c.alpha, mix);
4836  }
4837 
4838  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4839  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4840 
4841  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4842  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4843 
4844  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4845  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4846 
4847  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4848 };
4849 
4850 
4852 {
4853 public:
4854  unsigned char r;
4855  unsigned char g;
4856  unsigned char b;
4857 
4858  HPS_INLINE RGB24Color () {}
4859  explicit HPS_INLINE RGB24Color (unsigned char gray)
4860  : r (gray), g (gray), b (gray) {}
4861  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4862  : r (rr), g (gg), b (bb) {}
4863  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4864  r = Float::unit_to_byte(c.red);
4865  g = Float::unit_to_byte(c.green);
4866  b = Float::unit_to_byte(c.blue);
4867  }
4868 
4869  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4870  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4871 
4872  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4873  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4874 };
4875 
4876 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4877  red = Float::C2F(c32.r);
4878  green = Float::C2F(c32.g);
4879  blue = Float::C2F(c32.b);
4880 }
4881 
4882 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4883  red = Float::C2F(c32.r);
4884  green = Float::C2F(c32.g);
4885  blue = Float::C2F(c32.b);
4886 }
4887 
4888 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4889  red = c.red;
4890  green = c.green;
4891  blue = c.blue;
4892 }
4893 
4894 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4895  red = Float::C2F(c24.r);
4896  green = Float::C2F(c24.g);
4897  blue = Float::C2F(c24.b);
4898 }
4899 
4900 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4901 {
4902  r = c.r;
4903  g = c.g;
4904  b = c.b;
4905  a = 255;
4906 }
4907 
4908 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4909 {
4910  r = c.r;
4911  g = c.g;
4912  b = c.b;
4913  a = c.a;
4914 }
4915 
4916 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4917  red = Float::C2F(c32.r);
4918  green = Float::C2F(c32.g);
4919  blue = Float::C2F(c32.b);
4920  alpha = Float::C2F(c32.a);
4921 }
4922 
4923 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4924  red = Float::C2F(c32.r);
4925  green = Float::C2F(c32.g);
4926  blue = Float::C2F(c32.b);
4927  alpha = Float::C2F(c32.a);
4928 }
4929 
4930 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4931  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4932 }
4933 
4934 
4935 
4936 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4937  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4938 }
4939 
4940 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4941  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);
4942 }
4943 
4944 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4945  return RGBAS32Color(
4946  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4947  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4948  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4949  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4950 }
4951 
4952 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4953  return RGBA32Color(
4954  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4955  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4956  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4957  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4958 }
4959 
4960 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4961  return RGB24Color(
4962  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4963  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4964  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4965 }
4966 
4967 
4968 
4969 class HPS_API Quaternion {
4970 public:
4971  float w;
4972  float x;
4973  float y;
4974  float z;
4975 
4976  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4977 
4978  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) { }
4979 
4980  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4981 
4982  Quaternion const & Normalize() {
4983  float mag = Norm();
4984 
4985  if (mag > 0) {
4986  w /= mag;
4987  x /= mag;
4988  y /= mag;
4989  z /= mag;
4990  }
4991  return *this;
4992  }
4993 
4994  bool operator== (Quaternion const & q) const { return HPS::Float::Equals(x, q.x) && HPS::Float::Equals(y, q.y) && HPS::Float::Equals(z, q.z) && HPS::Float::Equals(w, q.w); }
4995  bool operator!= (Quaternion const & q) const { return !(*this == q); }
4996 
4997  bool Equals(Quaternion const & q, int in_tolerance = 32) const {
4998  return Float::Equals(x, q.x, in_tolerance) && Float::Equals(y, q.y, in_tolerance) && Float::Equals(z, q.z, in_tolerance) && Float::Equals(w, q.w, in_tolerance);
4999  }
5000 
5001  Quaternion operator* (Quaternion const & in_right) const {
5002  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
5003  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
5004  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
5005  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
5006  }
5007 
5008  Quaternion operator* (float in_right) const {
5009  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
5010  }
5011 
5012  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
5013  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
5014  }
5015 
5016  Quaternion operator/ (float in_right) const {
5017  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
5018  }
5019 
5020  Quaternion operator- (Quaternion const & in_right) const {
5021  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
5022  }
5023 
5024  Quaternion operator+ (Quaternion const & in_right) const {
5025  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
5026  }
5027 
5028  inline float Norm() const {
5029  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
5030  }
5031 
5032 
5033  Quaternion Log() const {
5034  Quaternion ret;
5035  float mag_q = Norm();
5036  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
5037 
5038  ret.w = static_cast<float>(log(mag_q));
5039 
5040  if (mag_V > 0) {
5041  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
5042 
5043  ret.x = x * scale;
5044  ret.y = y * scale;
5045  ret.z = z * scale;
5046  }
5047  else
5048  ret.x = ret.y = ret.z = 0;
5049 
5050  return ret;
5051  }
5052 
5053  Quaternion Exp() const {
5054  Quaternion ret;
5055  float ea = static_cast<float>(exp(w));
5056  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
5057  float scale = ea * sin(mag_V) / mag_V;
5058 
5059  ret.w = ea * cos(mag_V);
5060  ret.x = scale * x;
5061  ret.y = scale * y;
5062  ret.z = scale * z;
5063 
5064  return ret;
5065  }
5066 
5067  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
5068  Quaternion ret = *this + in_fraction * (in_right - *this);
5069  return ret.Normalize();
5070  }
5071 
5072 
5073  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
5074  Quaternion q3;
5075  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
5076 
5077  if (in_shortest_path_only && dot < 0) {
5078  dot = -dot;
5079  q3 = -1 * in_right;
5080  }
5081  else
5082  q3 = in_right;
5083 
5084  if (dot > -0.95f && dot < 0.95f) {
5085  float angle = static_cast<float>(acos(dot));
5086  float sina = static_cast<float>(sin(angle));
5087  float sinat = static_cast<float>(sin(angle*in_fraction));
5088  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
5089 
5090  return (*this * sinaomt + q3 * sinat) / sina;
5091  }
5092  else //if the angle is small, we use linear interpolation
5093  return Lerp(q3, in_fraction);
5094  }
5095 
5096 
5105  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
5106  Quaternion q1 = Slerp(in_right , in_fraction, false);
5107  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
5108 
5109  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
5110  }
5111 
5118  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
5119  Quaternion qni(w, -x, -y, -z);
5120 
5121  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
5122  }
5123 
5130  static Quaternion ComputeRotation(float in_degrees, HPS::Vector const & in_axis)
5131  {
5132  Vector normalized_axis(in_axis);
5133  normalized_axis.Normalize();
5134 
5135  Quaternion ret;
5136  float radians = Degrees_To_Radians(in_degrees);
5137  float sin_calc = sin(radians * 0.5f);
5138  ret.x = cos(radians * 0.5f) * normalized_axis.x;
5139  ret.y = sin_calc * normalized_axis.y;
5140  ret.z = sin_calc * normalized_axis.z;
5141  ret.w = sin_calc;
5142  return ret;
5143  }
5144 
5152  static Quaternion ComputeRotation(float in_x, float in_y, float in_z)
5153  {
5154  float x_radians = Degrees_To_Radians(in_x);
5155  float y_radians = Degrees_To_Radians(in_y);
5156  float z_radians = Degrees_To_Radians(in_z);
5157  float cy = cos(z_radians * 0.5f);
5158  float sy = sin(z_radians * 0.5f);
5159  float cp = cos(y_radians * 0.5f);
5160  float sp = sin(y_radians * 0.5f);
5161  float cr = cos(x_radians * 0.5f);
5162  float sr = sin(x_radians * 0.5f);
5163 
5164  Quaternion ret;
5165  ret.w = (cr * cp * cy) + (sr * sp * sy);
5166  ret.x = (sr * cp * cy) - (cr * sp * sy);
5167  ret.y = (cr * sp * cy) + (sr * cp * sy);
5168  ret.z = (cr * cp * sy) - (sr * sp * cy);
5169  return ret;
5170  }
5171 };
5172 
5174 {
5177  size_t dot_dc_count;
5178  size_t dot_3d_count;
5179  size_t line_dc_count;
5180  size_t line_3d_count;
5186  size_t text_3d_count;
5197  size_t raster_count;
5198  size_t segment_count;
5215 };
5216 
5217 typedef unsigned char byte;
5218 typedef signed char sbyte;
5219 typedef intptr_t WindowHandle;
5220 typedef int64_t TouchID;
5221 typedef intptr_t PlatformData;
5222 typedef intptr_t OpaqueHandle;
5223 
5224 /*
5225 HPS Lexicon:
5226 
5227 Concept Class -- A class that contains only enums and possibly static functions. The
5228  constructor is usually private because they are not intended to be instantiated.
5229 
5230 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
5231  database objects is subject to locking to prevent threading deadlocks. (2) The class
5232  of the same name, offering static functions to initiate operations that take place
5233  within the database.
5234 
5235 Key -- A reference counted smart pointer to an object in the database. The
5236 
5237 Kit -- A user space object that carries a complete specification for a geometry, attribute,
5238  option group, or other type. Modifying a kit has no effect on the database unless
5239  and until it is applied. Kits should generally be passed by reference because they
5240  are potentially very large and copying them can be arduous.
5241 
5242 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
5243  pointers should generally be passed by value to ensure the reference count is
5244  correct.
5245 
5246 User Space -- The external space occupied by all user code. User space objects are not
5247  in the database and are not subject to locking.
5248 
5249 */
5250 
5254 class SegmentKey;
5255 class AttributesControl;
5256 class LineKit;
5257 class LineKey;
5258 class TextKey;
5259 class TextKit;
5260 class Key;
5261 class VisibilityControl;
5262 class CameraControl;
5263 class SelectabilityControl;
5264 class TransparencyKit;
5265 class TransparencyControl;
5266 class CullingKit;
5267 class CullingControl;
5268 class GlyphKit;
5269 class ShapeKit;
5271 class GlyphDefinition;
5272 class ShapeDefinition;
5273 class GeometryInsertControl;
5274 class GlyphElement;
5275 class ShapeElement;
5276 class TextAttributeControl;
5277 class TextAttributeKit;
5278 class LineAttributeKit;
5279 class LineAttributeControl;
5280 class EdgeAttributeKit;
5281 class EdgeAttributeControl;
5282 class CurveAttributeKit;
5283 class CurveAttributeControl;
5284 class GlyphPoint;
5285 class MatrixKit;
5287 class TextureMatrixControl;
5288 class TextureDefinition;
5289 class MaterialMappingKit;
5290 class PBRMaterialKit;
5292 class MaterialKit;
5293 class MarkerKit;
5294 class MarkerKey;
5295 class DistantLightKit;
5296 class DistantLightKey;
5297 class CuttingSectionKit;
5298 class CuttingSectionKey;
5301 class CylinderAttributeKit;
5303 class Cylinder;
5304 class CylinderKey;
5305 class CylinderKit;
5306 class SphereKey;
5307 class SphereKit;
5308 class SphereAttributeKit;
5310 class PolygonKit;
5311 class PolygonKey;
5312 class CircleKey;
5313 class CircleKit;
5314 class CircularArcKey;
5315 class CircularArcKit;
5316 class CircularWedgeKey;
5317 class CircularWedgeKit;
5318 class IncludeKey;
5319 class InfiniteLineKey;
5320 class InfiniteLineKit;
5321 class SpotlightKey;
5322 class SpotlightKit;
5323 class NURBSCurveKey;
5324 class NURBSCurveKit;
5325 class NURBSSurfaceKey;
5326 class NURBSSurfaceKit;
5327 class TrimKit;
5328 class TrimElement;
5329 class EllipseKey;
5330 class EllipseKit;
5331 class EllipticalArcKey;
5332 class EllipticalArcKit;
5333 class ShellKit;
5334 class ShellKey;
5335 class Shell;
5336 class MeshKit;
5337 class MeshKey;
5338 class WindowKey;
5339 class Database;
5342 class Driver;
5343 class Search;
5344 class PerformanceKit;
5345 class PerformanceControl;
5348 class DrawingAttributeKit;
5350 class PortfolioKey;
5351 class Selection;
5352 class SelectionOptionsKit;
5353 class SelectionResults;
5354 class SelectionItem;
5355 class SelectionControl;
5356 class HighlightControl;
5357 class HighlightOptionsKit;
5358 class ImageDefinition;
5359 class ImageKit;
5360 class TextureDefinition;
5361 class TextureOptionsKit;
5362 class NamedStyleDefinition;
5364 class GlyphDefinition;
5365 class LinePatternOptionsKit;
5366 class LinePatternDefinition;
5367 class LinePatternKit;
5368 class LinePatternElement;
5370 class CubeMapDefinition;
5371 class ShaderKit;
5372 class ShaderDefinition;
5373 class EmergencyHandler;
5374 class EventDispatcher;
5375 class EventHandler;
5376 class Event;
5377 #if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
5378 class StandAloneWindowKey;
5380 #endif
5381 class ApplicationWindowKey;
5383 class OffScreenWindowKey;
5386 class VisualEffectsControl;
5389 class ObjectPoint;
5390 class WorldPoint;
5391 class CameraPoint;
5392 class InnerWindowPoint;
5393 class InnerPixelPoint;
5394 class WindowPoint;
5395 class PixelPoint;
5396 class VisibilityKit;
5397 class CameraKit;
5398 class SelectabilityKit;
5399 class MarkerAttributeKit;
5400 class LightingAttributeKit;
5401 class VisualEffectsKit;
5402 class PostProcessEffectsKit;
5403 class Portfolio;
5404 class SubwindowControl;
5405 class SubwindowKit;
5406 class World;
5407 class DebuggingControl;
5408 class DebuggingKit;
5409 class KeyPath;
5410 class ContourLineKit;
5411 class ContourLineControl;
5412 class UTF8;
5413 class StyleControl;
5414 class PortfolioControl;
5415 class ConditionalExpression;
5416 class ConditionControl;
5417 class WindowInfoKit;
5418 class WindowInfoControl;
5419 class FontInfoState;
5420 class FontInfoControl;
5421 class SearchOptionsKit;
5422 class AttributeLockControl;
5423 class AttributeLockKit;
5424 class ReferenceKey;
5425 class StyleKey;
5426 class BoundingKit;
5427 class BoundingControl;
5428 class TransformMaskKit;
5429 class TransformMaskControl;
5430 class ColorInterpolationKit;
5432 class UpdateOptionsKit;
5433 class UpdateOptionsControl;
5434 class GeometryKey;
5435 class TreeContext;
5438 class GridKit;
5439 class GridKey;
5443 class HighlightState;
5448 
5452 
5453 
5456 class HPS_API GlyphPoint
5457 {
5458 public:
5459 
5461  GlyphPoint();
5462 
5467  GlyphPoint(sbyte in_x, sbyte in_y);
5468 
5473  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5474 
5479  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5480 
5485  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5486 
5487  sbyte x;
5488  sbyte y;
5489 };
5490 
5493 enum class Type : uint32_t
5494 {
5495  None = 0x00000000,
5496  GenericMask = 0xffffff00,
5497 
5498  World = 0x00000001,
5499  UTF8 = 0x00000002,
5500  EventDispatcher = 0x00000003,
5501  EventHandler = 0x00000004,
5502  EventNotifier = 0x00000005,
5503  UpdateNotifier = 0x00000006,
5504  SearchResults = 0x00000008,
5505  FontSearchResults = 0x00000009,
5506  SelectionResults = 0x0000000a,
5507  SelectionItem = 0x0000000b,
5508  TreeContext = 0x0000000c,
5509  StreamToolkit = 0x0000000d,
5510  DriverEventHandler = 0x0000000e,
5511  HighlightSearchResults = 0x0000000f,
5512  OptimizeMappingResults = 0x00000010,
5513 
5514  IONotifier = 0x04000100,
5515  StreamImportNotifier = 0x04000101,
5516  STLImportNotifier = 0x04000102,
5517  OBJImportNotifier = 0x04000103,
5518  ExchangeImportNotifier = 0x04000104,
5519  SketchupImportNotifier = 0x04000105,
5520  ParasolidImportNotifier = 0x04000106,
5521  ExchangeTranslationNotifier = 0x04000107,
5522  ExchangeExportNotifier = 0x04000108,
5523  StreamExportNotifier = 0x04000109,
5524  ExchangeReloadNotifier = 0x0400010a,
5525  DWGImportNotifier = 0x0400010b,
5526  ExchangeParasolidImportNotifier = 0x0400010c,
5527  PointCloudImportNotifier = 0x0400010d,
5528  OOCImportNotifier = 0x0400010e,
5529  OBJExportNotifier = 0x0400010f,
5530  HCAImportNotifier = 0x04000110,
5531 
5532  SearchResultsIterator = 0x01000001,
5533  FontSearchResultsIterator = 0x01000002,
5534  SelectionResultsIterator = 0x01000003,
5535  HighlightSearchResultsIterator = 0x01000004,
5536  OptimizeMappingResultsIterator = 0x01000005,
5537 
5538  Kit = 0x01000000,
5539  MarkerKit = 0x01000010,
5540  SphereAttributeKit = 0x01000011,
5541  TextAttributeKit = 0x01000012,
5542  TransparencyKit = 0x01000013,
5543  VisibilityKit = 0x01000014,
5544  VisualEffectsKit = 0x01000015,
5545  CuttingSectionAttributeKit = 0x01000016,
5546  CircleKit = 0x01000017,
5547  CircularArcKit = 0x01000018,
5548  CircularWedgeKit = 0x01000019,
5549  CuttingSectionKit = 0x0100001a,
5550  CylinderKit = 0x0100001b,
5551  DistantLightKit = 0x0100001c,
5552  EllipseKit = 0x0100001d,
5553  EllipticalArcKit = 0x0100001e,
5554  InfiniteLineKit = 0x0100001f,
5555  LineKit = 0x01000020,
5556  NURBSCurveKit = 0x01000021,
5557  MeshKit = 0x01000022,
5558  NURBSSurfaceKit = 0x01000023,
5559  PolygonKit = 0x01000024,
5560  SphereKit = 0x01000025,
5561  SpotlightKit = 0x01000026,
5562  ShellKit = 0x01000027,
5563  TextKit = 0x01000028,
5564  MaterialKit = 0x01000029,
5565  TrimKit = 0x0100002a,
5566  TextureOptionsKit = 0x0100002c,
5567  LinePatternKit = 0x0100002d,
5568  GlyphKit = 0x0100002e,
5569  ImageKit = 0x0100002f,
5570  LinePatternOptionsKit = 0x01000030,
5571  CameraKit = 0x01000031,
5572  BoundingKit = 0x01000032,
5573  CullingKit = 0x01000033,
5574  CurveAttributeKit = 0x01000034,
5575  CylinderAttributeKit = 0x01000035,
5576  EdgeAttributeKit = 0x01000036,
5577  LightingAttributeKit = 0x01000037,
5578  LineAttributeKit = 0x01000038,
5579  MarkerAttributeKit = 0x01000039,
5580  MaterialMappingKit = 0x0100003a,
5581  //MatrixKit = 0x0100003b,
5582  NURBSSurfaceAttributeKit = 0x0100003c,
5583  PostProcessEffectsKit = 0x0100003d,
5584  SelectabilityKit = 0x0100003e,
5585  SelectionOptionsKit = 0x0100003f,
5586  StandAloneWindowOptionsKit = 0x01000040,
5587  OffScreenWindowOptionsKit = 0x01000041,
5588  ApplicationWindowOptionsKit = 0x01000042,
5589  HighlightOptionsKit = 0x01000043,
5590  LinePatternParallelKit = 0x01000044,
5591  SubwindowKit = 0x01000045,
5592  PerformanceKit = 0x01000046,
5593  HiddenLineAttributeKit = 0x01000047,
5594  DrawingAttributeKit = 0x01000048,
5595  ShaderKit = 0x01000049,
5596  DebuggingKit = 0x0100004a,
5597  ContourLineKit = 0x0100004b,
5598  StreamImportOptionsKit = 0x0100004c,
5599  StreamImportResultsKit = 0x0100004d,
5600  StreamExportOptionsKit = 0x0100004e,
5601  StreamExportResultsKit = 0x0100004f,
5602  WindowInfoKit = 0x01000050,
5603  ImageImportOptionsKit = 0x01000051,
5604  SearchOptionsKit = 0x01000052,
5605  ShaderImportOptionsKit = 0x01000053,
5606  HardcopyExportOptionsKit = 0x01000055, // These two use the same Impl, so
5607  HardcopyGDIExportOptionsKit = 0x01001055, // we make sure their bits are compatible here
5608  AttributeLockKit = 0x01000056,
5609  TransformMaskKit = 0x01000057,
5610  ColorInterpolationKit = 0x01000058,
5611  UpdateOptionsKit = 0x01000059,
5612  ImageExportOptionsKit = 0x0100005a,
5613  OBJImportOptionsKit = 0x0100005b,
5614  OBJImportResultsKit = 0x0100005c,
5615  STLImportOptionsKit = 0x0100005d,
5616  STLImportResultsKit = 0x0100005e,
5617  ShellOptimizationOptionsKit = 0x0100005f,
5618  ShellRelationOptionsKit = 0x01000060,
5619  ShellRelationResultsKit = 0x01000061,
5620  GridKit = 0x01000062,
5621  CutGeometryGatheringOptionsKit = 0x01000063,
5622  SegmentOptimizationOptionsKit = 0x01000064,
5623  PointCloudImportOptionsKit = 0x01000065,
5624  PointCloudImportResultsKit = 0x01000066,
5625  ShapeKit = 0x01000067,
5626  HighlightSearchOptionsKit = 0x01000068,
5627  PBRMaterialKit = 0x01000069,
5628 
5629  LinePatternElement = 0x03000000,
5630  SolidLinePatternElement = 0x03000001,
5631  BlankLinePatternElement = 0x03000002,
5632  GlyphLinePatternElement = 0x03000003,
5633 
5634  GlyphElement = 0x05000000,
5635  DotGlyphElement = 0x05000001,
5636  LineGlyphElement = 0x05000002,
5637  EllipseGlyphElement = 0x05000003,
5638  CircularArcGlyphElement = 0x05000004,
5639  InfiniteLineGlyphElement = 0x05000005,
5640  SphereGlyphElement = 0x05000006,
5641  ImageGlyphElement = 0x05000007,
5642 
5643  TrimElement = 0x07000000,
5644 
5645  ConditionalExpression = 0x09000000,
5646  NOTCondition = 0x09000001,
5647  ANDCondition = 0x09000002,
5648  ORCondition = 0x09000003,
5649  XORCondition = 0x09000004,
5650  EQCondition = 0x09000005,
5651  NEQCondition = 0x09000006,
5652  GTCondition = 0x09000007,
5653  LTCondition = 0x09000008,
5654  GTEQCondition = 0x09000009,
5655  LTEQCondition = 0x0900000A,
5656 
5657  ShapeElement = 0x0B000000,
5658  PolygonShapeElement = 0x0B000001,
5659  EllipseShapeElement = 0x0B000002,
5660  CircleShapeElement = 0x0B000003,
5661  EllipticalArcShapeElement = 0x0B000004,
5662  AnchorShapeElement = 0x0B000005,
5663  LineShapeElement = 0x0B000006,
5664  CircularArcShapeElement = 0x0B000007,
5665  LeaderLineClippingElement = 0x0B000008,
5666 
5667  MouseState = 0x01001001,
5668  TouchState = 0x01001002,
5669  KeyboardState = 0x01001003,
5670  FontInfoState = 0x01001004,
5671  HighlightState = 0x01001005,
5672 
5673  KeyPath = 0x01000F01,
5674 
5675  Key = 0x10000000,
5676  IncludeKey = 0x10000001,
5677  PortfolioKey = 0x10000002,
5678  StyleKey = 0x10000003,
5679 
5680  SegmentKey = 0x10200000,
5681  WindowKey = 0x10600000,
5682  StandAloneWindowKey = 0x10600001,
5683  OffScreenWindowKey = 0x10600002,
5684  ApplicationWindowKey = 0x10600003,
5685 
5686  GeometryKey = 0x10100000,
5687  ReferenceKey = 0x10100001,
5688  CircleKey = 0x10100002,
5689  CircularArcKey = 0x10100003,
5690  CircularWedgeKey = 0x10100004,
5691  CuttingSectionKey = 0x10100005,
5692  CylinderKey = 0x10100006,
5693  EllipseKey = 0x10100007,
5694  EllipticalArcKey = 0x10100008,
5695  InfiniteLineKey = 0x10100009,
5696  LineKey = 0x1010000a,
5697  DistantLightKey = 0x1010000b,
5698  SpotlightKey = 0x1010000c,
5699  MarkerKey = 0x1010000d,
5700  MeshKey = 0x1010000e,
5701  NURBSCurveKey = 0x1010000f,
5702  NURBSSurfaceKey = 0x10100010,
5703  PolygonKey = 0x10100011,
5704  ShellKey = 0x10100012,
5705  SphereKey = 0x10100013,
5706  TextKey = 0x10100014,
5707  GridKey = 0x10100015,
5708 
5709  Definition = 0x20000000,
5710  NamedStyleDefinition = 0x20000001,
5711  TextureDefinition = 0x20000002,
5712  LinePatternDefinition = 0x20000003,
5713  GlyphDefinition = 0x20000004,
5714  CubeMapDefinition = 0x20000005,
5715  ImageDefinition = 0x20000006,
5716  MaterialPaletteDefinition = 0x20000007,
5717  ShaderDefinition = 0x20000008,
5718  ShapeDefinition = 0x20000009,
5719 
5720  Control = 0x50000000,
5721  CameraControl = 0x50000001,
5722  SelectabilityControl = 0x50000002,
5723  MarkerAttributeControl = 0x50000003,
5724  SphereAttributeControl = 0x50000004,
5725  LightingAttributeControl = 0x50000005,
5726  CylinderAttributeControl = 0x50000006,
5727  TextAttributeControl = 0x50000007,
5728  LineAttributeControl = 0x50000008,
5729  EdgeAttributeControl = 0x50000009,
5730  CurveAttributeControl = 0x5000000a,
5731  ModellingMatrixControl = 0x5000000b,
5732  TextureMatrixControl = 0x5000000c,
5733  CullingControl = 0x5000000d,
5734  TransparencyControl = 0x5000000e,
5735  MaterialMappingControl = 0x5000000f,
5736  NURBSSurfaceAttributeControl = 0x50000010,
5737  PostProcessEffectsControl = 0x50000011,
5738  BoundingControl = 0x50000012,
5739  VisualEffectsControl = 0x50000013,
5740  SelectionOptionsControl = 0x50000014,
5741  HighlightOptionsControl = 0x50000015,
5742  DefinitionControl = 0x50000016,
5743  SelectionControl = 0x50000017,
5744  HighlightControl = 0x50000018,
5745  StandAloneWindowOptionsControl = 0x50600019, //Is a Window Key
5746  OffScreenWindowOptionsControl = 0x5060001a, //Is a Window Key
5747  ApplicationWindowOptionsControl = 0x5060001b, //Is a Window Key
5748  VisibilityControl = 0x5000001c,
5749  SubwindowControl = 0x5000001d,
5750  PerformanceControl = 0x5000001e,
5751  HiddenLineAttributeControl = 0x5000001f,
5752  DrawingAttributeControl = 0x50000020,
5753  DebuggingControl = 0x50000021,
5754  ContourLineControl = 0x50000022,
5755  StyleControl = 0x50000023,
5756  ConditionControl = 0x50000024,
5757  PortfolioControl = 0x50000025,
5758  WindowInfoControl = 0x50000026,
5759  AttributeLockControl = 0x50000027,
5760  TransformMaskControl = 0x50000028,
5761  ColorInterpolationControl = 0x50000029,
5762  UpdateOptionsControl = 0x50600030, //Is a Window Key
5763  CuttingSectionAttributeControl = 0x50000031,
5764 
5765  LibraryMask = 0x80FF0000,
5766 
5767  Sprocket = 0x80000000,
5768  Canvas = 0x80000001,
5769  Layout = 0x80000002,
5770  View = 0x80000003,
5771  Model = 0x80000004,
5772  Operator = 0x80000005,
5773  SprocketPath = 0x80000007,
5774 
5775  SprocketControl = 0xD0000000,
5776  OperatorControl = 0xD0000008,
5777  NavigationCubeControl = 0xD0000009,
5778  AxisTriadControl = 0xD000000A,
5779  AnimationControl = 0xD000000B,
5780 
5781  SprocketKit = 0x81000000,
5782 
5783  Metadata = 0x80001000,
5784  IntegerMetadata = 0x80001001,
5785  UnsignedIntegerMetadata = 0x80001002,
5786  DoubleMetadata = 0x80001003,
5787  StringMetadata = 0x80001004,
5788  TimeMetadata = 0x80001005,
5789  BooleanMetadata = 0x80001006,
5790 
5791  Animation = 0x80003000,
5792  Channel = 0x80003100,
5793  Sampler = 0x80003200,
5794  FloatSampler = 0x80003201,
5795  PointSampler = 0x80003202,
5796  VectorSampler = 0x80003203,
5797  RGBColorSampler = 0x80003204,
5798  QuaternionSampler = 0x80003205,
5799 
5800  Component = 0x80000200,
5801  Filter = 0x80000600,
5802  Capture = 0x80000a00,
5803  CADModel = 0x80000300,
5804  ComponentPath = 0x81001000,
5805 
5806  ExchangeMask = 0x80020000,
5807  ExchangeComponent = 0x80021200,
5808  ExchangeSheet = 0x80021201,
5809  ExchangeProductOccurrence = 0x80021202,
5810  ExchangeFilter = 0x80020601,
5811  ExchangeCapture = 0x80020a01,
5812  ExchangeCADModel = 0x80020301,
5813  ExchangeConfiguration = 0x81020001,
5814  ExchangeImportOptionsKit = 0x81020002,
5815  ExchangeExportACISOptionsKit = 0x81020003,
5816  ExchangeExportIGESOptionsKit = 0x81020004,
5817  ExchangeExportJTOptionsKit = 0x81020005,
5818  ExchangeExportParasolidOptionsKit = 0x81020006,
5819  ExchangeExportPRCOptionsKit = 0x81020007,
5820  ExchangeExportSTEPOptionsKit = 0x81020008,
5821  ExchangeExportSTLOptionsKit = 0x81020009,
5822  ExchangeExportU3DOptionsKit = 0x8102000a,
5823  ExchangeExportXMLOptionsKit = 0x8102000b,
5824  ExchangeTessellationOptionsKit = 0x8102000c,
5825  ExchangeModelFileImportOptionsKit = 0x8102000d,
5826  ExchangeTranslationOptionsKit = 0x8102000e,
5827  ExchangeNURBSConversionOptionsKit = 0x8102000f,
5828  ExchangeExport3MFOptionsKit = 0x81020010,
5829  ExchangeExportFBXOptionsKit = 0x81020011,
5830  ExchangeExportOBJOptionsKit = 0x81020012,
5831  ExchangeExportGLTFOptionsKit = 0x81020013,
5832 
5833  PublishMask = 0x80040000,
5834  PublishDocumentKit = 0x81040001,
5835  PublishPageKit = 0x81040002,
5836  PublishTemplateKit = 0x81040003,
5837  PublishAnnotationKit = 0x81040004,
5838  PublishArtworkKit = 0x81040005,
5839  PublishViewKit = 0x81040006,
5840  PublishTextKit = 0x81040007,
5841  PublishImageKit = 0x81040008,
5842  PublishTableKit = 0x81040009,
5843  PublishExportOptionsKit = 0x8104000a,
5844  PublishLinkKit = 0x8104000b,
5845  PublishButtonKit = 0x8104000c,
5846  PublishTextFieldKit = 0x8104000d,
5847  PublishSlideTableKit = 0x8104000e,
5848  PublishCheckBoxKit = 0x8104000f,
5849  PublishRadioButtonKit = 0x81040010,
5850  PublishListBoxKit = 0x81040011,
5851  PublishDropDownListKit = 0x81040012,
5852  PublishSignatureFieldKit = 0x81040013,
5853  PublishDataTableKit = 0x81040014,
5854 
5855  PublishDocumentKey = 0x80040001,
5856  PublishPageControl = 0x80040002,
5857 
5858  ExchangeParasolidMask = 0x80080000,
5859 
5860  SceneTree = 0x80008001,
5861  SceneTreeItem = 0x80008002,
5862 
5863  ComponentTree = 0x80008003,
5864  ComponentTreeItem = 0x80008004,
5865 
5866  SketchupMask = 0x80100000,
5867  SketchupImportOptionsKit = 0x81100001,
5868  SketchupImportResultsKit = 0x81100002,
5869 
5870  ParasolidMask = 0x80200000,
5871  ParasolidComponent = 0x80201201,
5872  ParasolidCADModel = 0x80200302,
5873  ParasolidImportOptionsKit = 0x81200003,
5874  ParasolidFacetTessellationKit = 0x81200004,
5875  ParasolidLineTessellationKit = 0x81200005,
5876  ParasolidExportOptionsKit = 0x81200006,
5877 
5878  DWGMask = 0x80400000,
5879  DWGComponent = 0x80401201,
5880  DWGLayer = 0x80401202,
5881  DWGLayout = 0x80400a03,
5882  DWGCADModel = 0x80400304,
5883  DWGImportOptionsKit = 0x81400005,
5884 
5885  OOCMask = 0x80800000,
5886  OOCImportOptionsKit = 0x81800001,
5887  OOCImportResultsKit = 0x81800002,
5888 
5889  HCAMask = 0x80110000,
5890  HCAImportOptionsKit = 0x81110001,
5891  HCAImportResultsKit = 0x81110002,
5892  HCAModel = 0x80110003,
5893  HCAModelTree = 0x80110004,
5894  HCAModelTreeItem = 0x80110005,
5895  HCANetworkImportOptionsKit = 0x81110006,
5896 
5897  HTMLMask = 0x80010000,
5898 
5899 
5900  IONotifierData = 0x84000200,
5901  StreamImportNotifierData = 0x84000201,
5902  STLImportNotifierData = 0x84000202,
5903  OBJImportNotifierData = 0x84000203,
5904  ExchangeImportNotifierData = 0x84020204,
5905  SketchupImportNotifierData = 0x84100205,
5906  ParasolidImportNotifierData = 0x84200206,
5907  ExchangeTranslationNotifierData = 0x84020207,
5908  ExchangeExportNotifierData = 0x84020208,
5909  StreamExportNotifierData = 0x84000209,
5910  DWGImportNotifierData = 0x8440020a,
5911  ExchangeParasolidImportNotifierData = 0x8408020b,
5912  PointCloudImportNotifierData = 0x8400020c,
5913  OOCImportNotifierData = 0x8480020d,
5914  OBJExportNotifierData = 0x8400020e,
5915  HCAImportNotifierData = 0x8411020f,
5916 
5917 };
5918 
5920 class HPS_API Memory
5921 {
5922 public:
5928  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5929 
5930 
5935  static void Free(void * in_pointer);
5936 
5937 private:
5939  Memory();
5940 };
5941 
5942 
5944 template <typename T>
5945 class NO_HPS_API Allocator
5946 {
5947 public:
5948  typedef T value_type;
5949  typedef value_type * pointer;
5950  typedef value_type const * const_pointer;
5951  typedef value_type & reference;
5952  typedef value_type const & const_reference;
5953  typedef size_t size_type;
5954  typedef ptrdiff_t difference_type;
5955 
5956 
5957  Allocator() {}
5958  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5959  ~Allocator() {}
5960 
5961  template <typename U> Allocator(Allocator<U> const &) {}
5962 
5963  template <typename U>
5964  struct rebind
5965  {
5966  typedef Allocator<U> other;
5967  };
5968 
5969 
5970  pointer address(reference x) const { return &x; }
5971  const_pointer address(const_reference x) const { return &x; }
5972 
5973  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5974  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5975 
5976 #if defined(_MSC_VER) || defined (__APPLE__)
5977  void construct(pointer p, const_reference x) { new(p) T(x); }
5978  void construct(pointer p, value_type && x) { new(p) T(std::move(x)); }
5979 #else
5980  template<typename U, typename... Args>
5981  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5982 #endif
5983  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5984 
5985  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5986 };
5987 
5988 template <typename T, typename U>
5989 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5990 
5991 template <typename T, typename U>
5992 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5993 
5995 class Exception : public std::runtime_error
5996 {
5997 public:
5998  Exception(char const * in_info) : std::runtime_error(in_info) { }
5999 };
6000 
6001 
6004 {
6005 public:
6006  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
6007  Exception(in_info) {}
6008 };
6009 
6010 
6014 {
6015 public:
6016  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
6017  Exception(in_info) {}
6018 };
6019 
6020 
6023 {
6024 public:
6025  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
6026  Exception(in_info) {}
6027 };
6028 
6029 
6032 {
6033 public:
6034  InvalidLicenseException(char const * in_info) :
6035  Exception(in_info) {}
6036 };
6037 
6038 
6041 {
6042 public:
6043  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
6044  Exception(in_info) {}
6045 };
6046 
6048 class IOException : public Exception
6049 {
6050 public:
6054  IOException(char const * in_info, IOResult in_result)
6055  : Exception(in_info), result(in_result) {}
6056 
6057  IOResult result;
6058 };
6059 
6060 
6062 class HPS_API Object
6063 {
6064 public:
6065 
6066  Object();
6067 
6068  Object(Object const & that);
6069 
6070  virtual ~Object();
6071 
6072  Object & operator=(Object const & other_object);
6073 
6077  Object(Object && in_that);
6078 
6079 
6083  Object & operator=(Object && in_that);
6084 
6091  virtual HPS::Type Type() const;
6092 
6094  static const HPS::Type staticType = HPS::Type::None;
6095 
6098  virtual HPS::Type ObjectType() const { return staticType; }
6099 
6104  virtual bool Empty() const {return (impl_ == 0);};
6105 
6107  virtual void Reset();
6108 
6115  bool HasType(HPS::Type in_mask) const;
6116 
6119  intptr_t GetClassID() const;
6120 
6126  intptr_t GetInstanceID() const;
6127 
6130  template <typename T>
6131  static intptr_t ClassID()
6132  {
6133  static const intptr_t ret = T().GetClassID();
6134  return ret;
6135  }
6136 private:
6137 
6138  friend class HPSI::Impl;
6139  friend class HPSI::KeyImpl;
6140  friend class HPSI::TicketImpl;
6141 
6142  HPSI::Impl * impl_;
6143 };
6144 
6145 
6147 class HPS_API Control : public Object
6148 {
6149 public:
6150  virtual HPS::Type Type() const { return ObjectType(); }
6151  static const HPS::Type staticType = HPS::Type::Control;
6152  HPS::Type ObjectType() const { return staticType; }
6153 
6154 #if !defined(_MSC_VER) || _MSC_VER >= 1900
6155  Control(Control const & in_that) = default;
6156 #endif
6157 
6158 protected:
6159  Control() {}
6160 
6164  Control(Control && in_that) : Object(std::move(in_that)) {}
6165 
6169  Control & operator=(Control && in_that)
6170  {
6171  this->Object::operator=(std::move(in_that));
6172  return *this;
6173  }
6174 };
6175 
6176 
6178 class HPS_API Kit : public Object
6179 {
6180 public:
6181  static const HPS::Type staticType = HPS::Type::Kit;
6182  HPS::Type ObjectType() const { return staticType; }
6183  virtual HPS::Type Type() const { return ObjectType(); }
6184 
6185 #if !defined(_MSC_VER) || _MSC_VER >= 1900
6186  Kit(Kit const & in_that) = default;
6187 #endif
6188 
6189 protected:
6190  Kit() {}
6191 
6195  Kit(Kit && in_that) : Object(std::move(in_that)) {}
6196 
6200  Kit & operator=(Kit && in_that)
6201  {
6202  this->Object::operator=(std::move(in_that));
6203  return *this;
6204  }
6205 };
6206 
6207 
6209 class HPS_API ObjectPoint : public Point
6210 {
6211 public:
6212 
6214  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6215 
6217  ObjectPoint(Point const & in_point):Point(in_point){}
6218 
6220  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6221 
6223  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
6224 
6226  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
6227 
6229  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6230 
6232  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6233 
6235  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
6236 
6238  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
6239 
6240 private:
6241 
6242  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
6243  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
6244  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
6245  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
6246  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
6247  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
6248 
6249 };
6250 
6252 class HPS_API WorldPoint : public Point
6253 {
6254 public:
6256  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6257 
6259  WorldPoint(Point const & in_point):Point(in_point){}
6260 
6262  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6263 
6265  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
6266 
6268  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
6269 
6271  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6272 
6274  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6275 
6277  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
6278 
6280  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
6281 
6282 private:
6283 
6284  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6285  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6286  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6287  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6288  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6289  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6290 
6291 };
6292 
6294 class HPS_API CameraPoint : public Point
6295 {
6296 public:
6298  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6299 
6301  CameraPoint(Point const & in_point):Point(in_point){}
6302 
6304  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6305 
6307  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
6308 
6310  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
6311 
6313  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6314 
6316  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6317 
6319  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
6320 
6322  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
6323 
6324 private:
6325  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6326  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6327  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6328  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6329  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6330  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6331 
6332 };
6333 
6335 class HPS_API InnerWindowPoint : public Point
6336 {
6337 public:
6338 
6340  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6341 
6343  InnerWindowPoint(Point const & in_point):Point(in_point){}
6344 
6346  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6347 
6349  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6350 
6352  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6353 
6355  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6356 
6358  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6359 
6361  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6362 
6364  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6365 
6366 private:
6367  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6368  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6369  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6370  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6371  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6372  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6373 };
6374 
6376 class HPS_API InnerPixelPoint : public Point
6377 {
6378 public:
6379 
6381  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6382 
6384  InnerPixelPoint(Point const & in_point):Point(in_point){}
6385 
6387  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6388 
6390  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6391 
6393  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6394 
6396  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6397 
6399  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6400 
6402  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6403 
6405  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6406 
6407 private:
6408  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6409  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6410  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6411  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6412  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6413  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6414 
6415 };
6416 
6418 class HPS_API WindowPoint : public Point
6419 {
6420 public:
6421 
6423  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6424 
6426  WindowPoint(Point const & in_point):Point(in_point){}
6427 
6429  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6430 
6432  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6433 
6435  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6436 
6438  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6439 
6441  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6442 
6444  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6445 
6447  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6448 
6449 private:
6450  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6451  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6452  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6453  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6454  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6455  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6456 };
6457 
6458 
6460 class HPS_API PixelPoint : public Point
6461 {
6462 public:
6464  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6465 
6467  PixelPoint(Point const & in_point):Point(in_point){}
6468 
6470  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6471 
6473  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6474 
6476  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6477 
6479  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6480 
6482  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6483 
6485  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6486 
6488  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6489 
6490 private:
6491  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6492  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6493  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6494  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6495  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6496  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6497 
6498 };
6499 
6502 class HPS_API Event
6503 {
6504 public:
6508  enum class Status : uint32_t
6509  {
6510  InProgress,
6511  Completed,
6512  Failed
6513  };
6514 
6516  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6517 
6518  virtual ~Event();
6519 
6521  intptr_t GetClassID() const;
6522 
6525  virtual Event * Clone() const=0;
6526 
6528  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6529 
6532  virtual intptr_t Freshen() const { return 0; }
6533 
6535  intptr_t GetChannel() const { return channel; }
6536 
6538  Time GetTimeStamp() const { return time_stamp; }
6539 
6541  bool IsConsumable() const { return consumable; }
6542 
6543  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6544  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6545 
6546 protected:
6547  intptr_t channel;
6548  bool consumable;
6549 
6550 private:
6551  friend class HPSI::EventDispatcherImpl;
6552  Time time_stamp;
6553 };
6554 
6555 
6558 class HPS_API EventNotifier : public Object
6559 {
6560 public:
6561 
6563  EventNotifier();
6564 
6567  EventNotifier(EventNotifier const & in_that);
6568 
6572  EventNotifier(EventNotifier && in_that);
6573 
6577  EventNotifier & operator=(EventNotifier && in_that);
6578 
6579  virtual ~EventNotifier();
6580 
6581  static const HPS::Type staticType = HPS::Type::EventNotifier;
6582  HPS::Type ObjectType() const {return staticType;};
6583 
6587  EventNotifier & operator=(EventNotifier const & in_that);
6588 
6591  virtual void Assign(EventNotifier const & in_that);
6592 
6595  EventNotifier const & Wait() const;
6596 
6599  Event::Status Status() const;
6600 };
6601 
6603 enum class KeyboardCode : uint32_t
6604 {
6605  None = 0,
6606 
6607  Backspace = 8,
6608  Tab = 9,
6609  Clear = 11,
6610  Return = 13,
6611  Shift = 16,
6612  Control = 17,
6613  Alt = 18,
6614  Pause = 19,
6615  Escape = 27,
6616 
6617  Space = 32,
6618  ExclamationMark,
6619  DoubleQuote,
6620  Number,
6621  Dollar,
6622  Percent,
6623  Ampersand,
6624  SingleQuote,
6625  OpenParen,
6626  CloseParen,
6627 
6628  Asterisk,
6629  Plus,
6630  Comma,
6631  Hyphen,
6632  Period,
6633  Slash,
6634 
6635  D0,
6636  D1,
6637  D2,
6638  D3,
6639  D4,
6640  D5,
6641  D6,
6642  D7,
6643  D8,
6644  D9,
6645 
6646  Colon,
6647  Semicolon,
6648  LessThan,
6649  Equal,
6650  GreaterThan,
6651  QuestionMark,
6652  AtSymbol,
6653 
6654  A,
6655  B,
6656  C,
6657  D,
6658  E,
6659  F,
6660  G,
6661  H,
6662  I,
6663  J,
6664  K,
6665  L,
6666  M,
6667  N,
6668  O,
6669  P,
6670  Q,
6671  R,
6672  S,
6673  T,
6674  U,
6675  V,
6676  W,
6677  X,
6678  Y,
6679  Z,
6680 
6681  OpenBrackets,
6682  Backslash,
6683  CloseBrackets,
6684  Caret,
6685  Underscore,
6686  Backtick,
6687 
6688  a,
6689  b,
6690  c,
6691  d,
6692  e,
6693  f,
6694  g,
6695  h,
6696  i,
6697  j,
6698  k,
6699  l,
6700  m,
6701  n,
6702  o,
6703  p,
6704  q,
6705  r,
6706  s,
6707  t,
6708  u,
6709  v,
6710  w,
6711  x,
6712  y,
6713  z,
6714 
6715  OpenBrace,
6716  VerticalBar,
6717  ClosingBrace,
6718  Tilde,
6719  Delete,
6720 
6721  Insert=1024,
6722  Home,
6723  End,
6724  PageUp,
6725  PageDown,
6726 
6727  Help,
6728 
6729  Left,
6730  Up,
6731  Right,
6732  Down,
6733 
6734  NumPad0,
6735  NumPad1,
6736  NumPad2,
6737  NumPad3,
6738  NumPad4,
6739  NumPad5,
6740  NumPad6,
6741  NumPad7,
6742  NumPad8,
6743  NumPad9,
6744 
6745  F1,
6746  F2,
6747  F3,
6748  F4,
6749  F5,
6750  F6,
6751  F7,
6752  F8,
6753  F9,
6754  F10,
6755  F11,
6756  F12,
6757  F13,
6758  F14,
6759  F15,
6760  F16,
6761  F17,
6762  F18,
6763  F19,
6764  F20,
6765  F21,
6766  F22,
6767  F23,
6768  F24,
6769 
6770  CapsLock,
6771  NumLock,
6772  ScrollLock,
6773  LeftShift,
6774  RightShift,
6775  LeftCtrl,
6776  RightCtrl,
6777  LeftAlt,
6778  RightAlt,
6779 
6780  Select,
6781  Print,
6782  Execute,
6783  PrintScreen,
6784 };
6785 
6786 
6788 class NO_HPS_API Touch
6789 {
6790 public:
6791 
6794  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6795 
6800  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6801  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6802 
6806  inline bool operator==(Touch const & in_that) const
6807  {
6808  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6809  }
6810 
6814  inline bool operator!=(Touch const & in_that) const
6815  {
6816  return !(*this == in_that);
6817  }
6818 
6819  TouchID ID;
6821  size_t TapCount;
6822 };
6829 typedef std::vector<Point, Allocator<Point> > PointArray;
6830 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6831 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6832 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6833 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6834 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6835 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6836 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6837 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6838 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6839 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6840 typedef std::vector<int, Allocator<int> > IntArray;
6841 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6842 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6843 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6844 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6845 typedef std::vector<float, Allocator<float> > FloatArray;
6846 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6847 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6848 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6849 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6850 typedef std::vector<ShapeElement, Allocator<ShapeElement> > ShapeElementArray;
6851 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6852 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6853 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6854 typedef std::vector<bool, Allocator<bool> > BoolArray;
6855 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6856 typedef std::vector<Key, Allocator<Key> > KeyArray;
6857 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6858 typedef std::vector<char, Allocator<char> > CharArray;
6859 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6860 typedef std::vector<byte, Allocator<byte> > ByteArray;
6861 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6862 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6863 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6864 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6865 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6866 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6867 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6868 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6869 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6870 typedef std::vector<ConditionalExpression, Allocator<ConditionalExpression> > ConditionalExpressionArray;
6871 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6872 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6873 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6874 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6875 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6876 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6877 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6878 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6879 typedef std::vector<ShapeDefinition, Allocator<ShapeDefinition> > ShapeDefinitionArray;
6880 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6881 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6882 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6883 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6884 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6885 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6886 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6887 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6888 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6889 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6890 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6891 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6892 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6893 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6894 typedef std::vector<Text::MarginUnits, Allocator<Text::MarginUnits> > TextMarginUnitsArray;
6895 typedef std::vector<PointArrayArray, Allocator<PointArrayArray> > PointArrayArrayArray;
6896 typedef std::vector<Drawing::ClipSpace, Allocator<Drawing::ClipSpace> > ClipSpaceArray;
6897 typedef std::vector<Drawing::ClipOperation, Allocator<Drawing::ClipOperation> > ClipOperationArray;
6898 typedef std::vector<MatrixKit, Allocator<MatrixKit> > MatrixKitArray;
6899 typedef std::vector<int32_t, Allocator<int32_t>> Int32Array;
6900 typedef std::vector<int64_t, HPS::Allocator<int64_t>> Int64Array;
6901 typedef std::vector<Line::CoordinateSpace, Allocator<Line::CoordinateSpace>> LineCoordinateSpaceArray;
6902 typedef std::vector<Drawing::Overlay, Allocator<Drawing::Overlay>> DrawingOverlayArray;
6903 typedef std::vector<HighlightState, Allocator<HighlightState>> HighlightStateArray;
6904 typedef std::vector<ImageKit, Allocator<ImageKit>> ImageKitArray;
6905 typedef std::vector<HPS::Type, Allocator<HPS::Type> > TypeArray;
6906 typedef std::vector<ShellKey, Allocator<ShellKey> > ShellKeyArray;
6907 typedef std::vector<LineKey, Allocator<LineKey> > LineKeyArray;
6908 
6913 class HPS_API ShapeCoordinate
6914 {
6915 public:
6917  ShapeCoordinate();
6918 
6922  ShapeCoordinate(float in_x, float in_y);
6923 
6928  ShapeCoordinate(float in_x, float in_y, FloatArray const & in_margins);
6929 
6935  ShapeCoordinate(float in_x, float in_y, size_t in_count, float const in_margins []);
6936 
6941  ShapeCoordinate(float in_x, float in_y, float in_radius);
6942 
6948  ShapeCoordinate(float in_x, float in_y, float in_radius, FloatArray const & in_margins);
6949 
6956  ShapeCoordinate(float in_x, float in_y, float in_radius, size_t in_count, float const in_margins []);
6957 
6961  bool Equals(ShapeCoordinate const & in_that) const;
6962 
6966  bool operator==(ShapeCoordinate const & in_that) const { return Equals(in_that); }
6967 
6971  bool operator!=(ShapeCoordinate const & in_that) const { return !Equals(in_that); }
6972 
6979  ShapeCoordinate & SetMargins(float in_margin_one, float in_margin_two = 0.0f, float in_margin_three = 0.0f, float in_margin_four = 0.0f);
6980 
6984  bool ShowMargins(FloatArray & out_margins) const;
6985 
6988  ShapeCoordinate & UnsetMargins();
6989 
6990  float x;
6991  float y;
6992  float radius;
6993  FloatArray margins;
6994 };
6995 
6998 class HPS_API ShapePoint
6999 {
7000 public:
7002  ShapePoint();
7003 
7007  ShapePoint(ShapeCoordinate const & in_x, ShapeCoordinate const & in_y);
7008 
7015  ShapePoint(float in_x, float in_y);
7016 
7020  bool Equals(ShapePoint const & in_that) const { return (x == in_that.x && y == in_that.y); }
7021 
7025  bool operator==(ShapePoint const & in_that) const { return Equals(in_that); }
7026 
7030  bool operator!=(ShapePoint const & in_that) const { return !Equals(in_that); }
7031 
7032  ShapeCoordinate x;
7033  ShapeCoordinate y;
7034 };
7035 
7036 typedef std::vector<ShapePoint, Allocator<ShapePoint> > ShapePointArray;
7037 
7039 class HPS_API SearchResultsIterator : public Object
7040 {
7041 public:
7042 
7045 
7049  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
7050 
7055 
7059  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
7060 
7062 
7063  static const HPS::Type staticType = HPS::Type::SearchResultsIterator;
7064  HPS::Type ObjectType() const {return staticType;}
7065 
7070  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
7071 
7076  void Set(SearchResultsIterator const & in_search_results_iterator);
7077 
7079  void Next();
7080 
7083  SearchResultsIterator & operator++();
7084 
7087  SearchResultsIterator operator++(int in_val);
7088 
7091  bool operator==(SearchResultsIterator const & in_search_results_iterator);
7092 
7095  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
7096 
7100  bool IsValid() const;
7101 
7103  void Reset();
7104 
7108  Key GetItem() const;
7109 
7112  Key operator*() const;
7113 
7116  SearchTypeArray GetResultTypes() const;
7117 };
7118 
7120 class HPS_API SearchResults : public Object
7121 {
7122 public:
7124  SearchResults();
7125 
7128  SearchResults(SearchResults const & in_search_results);
7129 
7133  SearchResults(SearchResults && in_that);
7134 
7138  SearchResults & operator=(SearchResults && in_that);
7139 
7141  virtual void Reset();
7142 
7144  ~SearchResults();
7145 
7146  static const HPS::Type staticType = HPS::Type::SearchResults;
7147  HPS::Type ObjectType() const {return staticType;}
7148 
7152  void Assign(SearchResults const & in_search_results);
7153 
7157  SearchResults & operator=(SearchResults const & in_search_results);
7158 
7161  size_t GetCount() const;
7162 
7165  SearchResultsIterator GetIterator() const;
7166 };
7167 
7169 class HPS_API FontSearchResultsIterator : public Object
7170 {
7171 public:
7172 
7175 
7179  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
7180 
7185 
7190  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
7191 
7192 
7196  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
7197 
7199 
7200  static const HPS::Type staticType = HPS::Type::FontSearchResultsIterator;
7201  HPS::Type ObjectType() const {return staticType;}
7202 
7203 
7208  void Set(FontSearchResultsIterator const & in_search_results_iterator);
7209 
7211  void Next();
7212 
7215  FontSearchResultsIterator & operator++();
7216 
7219  FontSearchResultsIterator operator++(int in_val);
7220 
7223  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
7224 
7227  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
7228 
7232  bool IsValid() const;
7233 
7235  void Reset();
7236 
7240  FontInfoState GetItem() const;
7241 
7244  FontInfoState operator*() const;
7245 
7246 };
7247 
7249 class HPS_API FontSearchResults : public Object
7250 {
7251 public:
7252 
7255 
7258  FontSearchResults(FontSearchResults const & in_search_results);
7259 
7264 
7268  FontSearchResults & operator=(FontSearchResults && in_that);
7269 
7271  virtual void Reset();
7272 
7274  ~FontSearchResults();
7275 
7276  static const HPS::Type staticType = HPS::Type::FontSearchResults;
7277  HPS::Type ObjectType() const {return staticType;}
7278 
7282  void Assign(FontSearchResults const & in_search_results);
7283 
7284 
7288  FontSearchResults & operator=(FontSearchResults const & in_search_results);
7289 
7292  size_t GetCount() const;
7293 
7296  FontSearchResultsIterator GetIterator() const;
7297 };
7298 
7300 class HPS_API UTF8
7301 {
7302 public:
7303 
7305  UTF8();
7306 
7308  ~UTF8();
7309 
7316  UTF8(char const * in_string, char const * in_locale = 0);
7317 
7320  UTF8(wchar_t const * in_string);
7321 
7324  UTF8(UTF8 const & in_that);
7325 
7328  UTF8(UTF8 && in_that);
7329 
7333  UTF8 & Assign(UTF8 && in_utf8);
7334 
7337  inline UTF8 & operator= (UTF8 && in_utf8)
7338  {
7339  return Assign(std::move(in_utf8));
7340  }
7341 
7346  size_t ToWStr(wchar_t * out_wide_string) const;
7347 
7351  size_t ToWStr(WCharArray & out_wide_string) const;
7352 
7355  inline bool IsValid() const
7356  {
7357  return (_length > 0);
7358  }
7359 
7362  inline bool Empty() const
7363  {
7364  return (_length == 0);
7365  }
7366 
7368  void Clear();
7369 
7371  void Reset() { Clear(); }
7372 
7376  inline size_t GetLength() const
7377  {
7378  return _length;
7379  }
7380 
7384  inline size_t GetWStrLength() const
7385  {
7386  return ToWStr(0);
7387  }
7388 
7391  inline char const * GetBytes() const
7392  {
7393  return _text;
7394  }
7395 
7398  inline operator char const * () const
7399  {
7400  return _text;
7401  }
7402 
7405  char At(size_t in_index) const
7406  {
7407  if(!IsValid())
7408  throw InvalidObjectException();
7409  else if(in_index >= _length)
7410  throw IndexOutOfRangeException();
7411  else
7412  return _text[in_index];
7413  }
7414 
7418  UTF8 & Assign(UTF8 const & in_utf8);
7419 
7423  inline UTF8 & operator= (UTF8 const & in_utf8)
7424  {
7425  return Assign(in_utf8);
7426  }
7427 
7431  UTF8 & operator+= (UTF8 const & in_utf8);
7432 
7436  UTF8 & operator+= (char const * in_utf8);
7437 
7441  UTF8 operator+ (UTF8 const & in_utf8) const;
7442 
7446  UTF8 operator+ (char const * in_utf8) const;
7447 
7451  bool operator== (UTF8 const & in_utf8) const;
7452 
7456  bool operator!= (UTF8 const & in_utf8) const
7457  {
7458  return !(*this == in_utf8);
7459  }
7460 
7464  bool operator== (char const * in_utf8) const;
7465 
7469  bool operator!= (char const * in_utf8) const
7470  {
7471  return !(*this == in_utf8);
7472  }
7473 
7478  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
7479  {
7480  return in_right == in_left;
7481  }
7482 
7487  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
7488  {
7489  return in_right != in_left;
7490  }
7491 
7496  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
7497  {
7498  return in_right == UTF8(in_left);
7499  }
7500 
7505  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
7506  {
7507  return in_right != UTF8(in_left);
7508  }
7509 
7514  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
7515  {
7516  return UTF8(in_left, "utf8") + in_right;
7517  }
7518 
7523  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
7524  {
7525  return UTF8(in_left) + in_right;
7526  }
7527 
7528 
7531  size_t GetHash() const;
7532 
7533  friend class HPSI::String;
7534 
7535 private:
7536 
7537  size_t internal_encode(wchar_t const * in_wide_string);
7538  static size_t internal_decode(size_t in_length, const char* in_utf8_string, wchar_t * out_wide_string);
7539  size_t internal_decode(wchar_t * out_wide_string) const;
7540 
7541  char * _text;
7542  size_t _length;
7543  mutable size_t _hash_key;
7544  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7545  char _buffer[_buffer_size];
7546 };
7547 
7549 struct UTF8Hasher {
7550  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7551  {
7552  return in_utf8.GetHash();
7553  }
7554 };
7555 
7558 class HPS_API ConditionalExpression : public Object
7559 {
7560 public:
7561 
7564 
7567  ConditionalExpression(char const * in_condition);
7568 
7571  ConditionalExpression(float in_number);
7572 
7575  ConditionalExpression(HPS::Condition::Intrinsic in_special);
7576 
7580 
7585 
7589  ConditionalExpression & operator=(ConditionalExpression && in_that);
7590 
7591  static const HPS::Type staticType = HPS::Type::ConditionalExpression;
7592  HPS::Type ObjectType() const { return staticType; }
7593 
7597  bool ShowCondition(UTF8 & out_condition) const;
7598 
7602  bool ShowNumber(float & out_number) const;
7603 
7607  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7608 
7612  bool ShowOperands(ConditionalExpressionArray & out_operands) const;
7613 
7617  ConditionalExpression & operator=(ConditionalExpression const & in_that);
7618 
7622  bool Equals(ConditionalExpression const & in_that) const;
7623 
7627  bool operator==(ConditionalExpression const & in_that) const;
7628 
7632  bool operator!=(ConditionalExpression const & in_that) const;
7633 
7637  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7638 
7642  bool IsSatisfiedBy(char const * in_condition) const;
7643 
7647  ConditionalExpression OR(ConditionalExpression const & in_operand2) const;
7648 
7652  ConditionalExpression XOR(ConditionalExpression const & in_operand2) const;
7653 
7657  ConditionalExpression AND(ConditionalExpression const & in_operand2) const;
7658 
7662  ConditionalExpression EQ(ConditionalExpression const & in_operand2) const;
7663 
7667  ConditionalExpression NEQ(ConditionalExpression const & in_operand2) const;
7668 
7672  ConditionalExpression GT(ConditionalExpression const & in_operand2) const;
7673 
7677  ConditionalExpression LT(ConditionalExpression const & in_operand2) const;
7678 
7682  ConditionalExpression GTEQ(ConditionalExpression const & in_operand2) const;
7683 
7687  ConditionalExpression LTEQ(ConditionalExpression const & in_operand2) const;
7688 
7691  ConditionalExpression operator !() const;
7692 
7696  ConditionalExpression operator ||(ConditionalExpression const & in_operand2) const;
7697 
7701  ConditionalExpression operator ^(ConditionalExpression const & in_operand2) const;
7702 
7706  ConditionalExpression operator &&(ConditionalExpression const & in_operand2) const;
7707 
7708 
7712  static ConditionalExpression NOT(ConditionalExpression const & in_operand);
7713 
7718  static ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7719 
7720 
7725  static ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7726 
7731  static ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7732 
7737  static ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7738 
7743  static ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7744 
7749  static ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7750 
7755  static ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7756 
7761  static ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7762 
7767  static ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7768 
7769  friend HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7770  friend HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7771  friend HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7772  friend HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7773 
7774  friend HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7775  friend HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7776  friend HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7777  friend HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7778  friend HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7779  friend HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7780 };
7781 
7782 
7786 HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7787 
7792 HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7793 
7798 HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7799 
7804 HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7805 
7810 HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7811 
7816 HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7817 
7822 HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7823 
7828 HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7829 
7834 HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7835 
7840 HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7841 
7842 
7843 
7847 class HPS_API Key : public Object
7848 {
7849 public:
7850 
7852  Key();
7853 
7855  Key(Key const & in_that);
7856 
7858  explicit Key(Control const & in_control);
7859 
7863  Key(Key && in_that);
7864 
7868  Key & operator=(Key && in_that);
7869 
7871  virtual ~Key();
7872 
7873  static const HPS::Type staticType = HPS::Type::Key;
7874  HPS::Type ObjectType() const {return staticType;};
7875 
7877  bool HasOwner() const;
7878 
7880  SegmentKey Up() const;
7881 
7883  SegmentKey Owner() const;
7884 
7886  void Delete();
7887 
7889  void MoveTo(SegmentKey const & in_new_owner);
7890 
7893  Key CopyTo(SegmentKey const & in_destination) const;
7894 
7898  Key & operator=(Key const & in_that);
7899 
7902  virtual void Assign(Key const & in_that);
7903 
7905  bool Equals(Key const & in_that) const;
7906 
7908  bool operator!= (Key const & in_that) const;
7909 
7911  bool operator== (Key const & in_that) const;
7912 
7915  size_t GetHash() const;
7916 };
7917 
7919 struct KeyHasher {
7920  inline size_t operator()(const HPS::Key & in_key) const
7921  {
7922  return in_key.GetHash();
7923  }
7924 };
7925 
7926 
7929 class HPS_API SegmentKey : public Key
7930 {
7931 public:
7933  SegmentKey();
7934 
7936  SegmentKey(SegmentKey const & in_that);
7937 
7939  SegmentKey & operator=(SegmentKey const & other);
7940 
7944  SegmentKey(SegmentKey && in_that);
7945 
7949  SegmentKey & operator=(SegmentKey && in_that);
7950 
7952  explicit SegmentKey(Key const & in_that);
7953 
7955  ~SegmentKey();
7956 
7957  static const HPS::Type staticType = HPS::Type::SegmentKey;
7958  HPS::Type ObjectType() const {return staticType;};
7959 
7961  UTF8 Name() const;
7962 
7965  SegmentKey & SetName(char const * in_name);
7966 
7969  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7970 
7973  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7974 
7976  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7977 
7979  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7980 
7982  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7983 
7984 
7985 
7987  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7988 
7990  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7991 
7993  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7994 
7995 
7997  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7998 
8000  size_t Find(SearchOptionsKit const & in_options) const;
8001 
8002 
8005  IncludeKey IncludeSegment(SegmentKey const & in_seg);
8006 
8010  IncludeKey IncludeSegment(SegmentKey const & in_seg, ConditionalExpression const & in_conditional);
8011 
8012 
8018  ReferenceKey ReferenceGeometry(Key const & in_key);
8019 
8027  ReferenceKey ReferenceGeometry(Key const & in_key, ConditionalExpression const & in_conditional);
8028 
8029 
8031  size_t ShowSubsegments() const;
8032 
8034  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
8035 
8039  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
8040 
8044  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
8045 
8049  size_t ShowStylers(SegmentKeyArray & out_segments) const;
8050 
8054  size_t ShowStylers(StyleKeyArray & out_styles) const;
8055 
8059  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
8060 
8064  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
8065 
8066 
8067 
8069  StyleControl GetStyleControl();
8070 
8072  StyleControl const GetStyleControl() const;
8073 
8074 
8076  PortfolioControl GetPortfolioControl();
8077 
8079  PortfolioControl const GetPortfolioControl() const;
8080 
8081 
8083  SegmentKey & SetCondition(char const * in_condition);
8084 
8086  SegmentKey & SetConditions(UTF8Array const & in_conditions);
8087 
8089  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
8090 
8092  SegmentKey & UnsetConditions();
8093 
8095  bool ShowConditions(UTF8Array & out_conditions) const;
8096 
8098  ConditionControl GetConditionControl();
8099 
8101  ConditionControl const GetConditionControl() const;
8102 
8103 
8105  SegmentKey & SetMaterialPalette(char const * in_name);
8106 
8108  SegmentKey & UnsetMaterialPalette();
8109 
8111  bool ShowMaterialPalette(UTF8 & out_name) const;
8112 
8113 
8120  SegmentKey & SetPriority(int in_priority);
8121 
8124  SegmentKey & UnsetPriority();
8125 
8129  bool ShowPriority(int & out_priority) const;
8130 
8135  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
8136 
8142  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
8143 
8148  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
8149 
8153  SegmentKey & UnsetUserData(intptr_t in_index);
8154 
8159  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
8160 
8164  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
8165 
8168  SegmentKey & UnsetAllUserData();
8169 
8171  size_t ShowUserDataCount() const;
8172 
8177  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
8178 
8182  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
8183 
8188  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
8189 
8190 
8192  LineKey InsertLine(LineKit const & in_kit);
8193 
8195  LineKey InsertLine(size_t in_count, Point const in_pts[]);
8196 
8198  LineKey InsertLine(PointArray const & in_pts);
8199 
8201  LineKey InsertLine(Point const & pt1, Point const & pt2);
8202 
8203 
8205  CylinderKey InsertCylinder(CylinderKit const & in_kit);
8206 
8208  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);
8209 
8211  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
8212 
8214  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
8215 
8216 
8221  SphereKey InsertSphere(SphereKit const & in_kit);
8222 
8230  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));
8231 
8233  CircleKey InsertCircle(CircleKit const & in_kit);
8234 
8236  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
8237 
8239  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
8240 
8241 
8243  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
8244 
8246  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
8247 
8248 
8250  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
8251 
8253  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
8254 
8255 
8257  EllipseKey InsertEllipse(EllipseKit const & in_kit);
8258 
8260  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
8261 
8262 
8264  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
8265 
8267  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float in_start, float in_end);
8268 
8269 
8271  PolygonKey InsertPolygon(PolygonKit const & in_kit);
8272 
8274  PolygonKey InsertPolygon(PointArray const & in_points);
8275 
8277  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
8278 
8279 
8281  ShellKey InsertShell(ShellKit const & in_kit);
8282 
8284  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
8285 
8287  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
8288 
8296  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
8297 
8299  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
8300 
8302  MeshKey InsertMesh(MeshKit const & in_kit);
8303 
8305  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
8306 
8308  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
8309 
8310 
8312  MarkerKey InsertMarker(Point const & in_position);
8313 
8315  MarkerKey InsertMarker(MarkerKit const & in_kit);
8316 
8317 
8319  DistantLightKey InsertDistantLight(Vector const & in_direction);
8320 
8322  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
8323 
8324 
8326  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
8327 
8329  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
8330 
8332  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
8333 
8335  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
8336 
8337 
8339  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
8340 
8342  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
8343 
8344 
8346  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
8347 
8349  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
8350 
8351 
8353  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
8354 
8356  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);
8357 
8359  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);
8360 
8361 
8363  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
8364 
8366  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);
8367 
8369  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[]);
8370 
8372  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);
8373 
8375  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[]);
8376 
8377 
8379  TextKey InsertText(TextKit const & in_kit);
8380 
8385  TextKey InsertText(Point const & in_position, char const * in_text);
8386 
8387 
8388 
8390  GridKey InsertGrid(GridKit const & in_kit);
8391 
8393  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);
8394 
8395 
8396 
8403  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
8404 
8412  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
8413 
8421  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
8422 
8430  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
8431 
8439  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
8440 
8448  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
8449 
8454  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
8455 
8460  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
8461 
8466  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
8467 
8472  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
8473 
8478  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
8479 
8484  ShellKey InsertShellFromGeometry(EllipseKey const & in_ellipse);
8485 
8490  ShellKey InsertShellFromGeometry(CircleKey const & in_circle);
8491 
8496  ShellKey InsertShellFromGeometry(CircularWedgeKey const & in_circular_wedge);
8497 
8502  ShellKey InsertShellFromGeometry(TextKey const & in_text);
8503 
8504 
8506  SegmentKey & SetAttributeLock(AttributeLockKit const & in_kit);
8507 
8509  SegmentKey & UnsetAttributeLock();
8510 
8514  bool ShowAttributeLock(AttributeLockKit & out_kit) const;
8515 
8517  AttributeLockControl GetAttributeLockControl();
8518 
8520  AttributeLockControl const GetAttributeLockControl() const;
8521 
8522 
8524  SegmentKey & SetBounding(BoundingKit const & in_kit);
8525 
8527  SegmentKey & UnsetBounding();
8528 
8532  bool ShowBounding(BoundingKit & out_kit) const;
8533 
8535  BoundingControl GetBoundingControl();
8536 
8538  BoundingControl const GetBoundingControl() const;
8539 
8540 
8542  SegmentKey & SetCamera(CameraKit const & in_kit);
8543 
8545  SegmentKey & UnsetCamera();
8546 
8548  bool ShowCamera(CameraKit & out_kit) const;
8549 
8551  CameraControl GetCameraControl();
8552 
8554  CameraControl const GetCameraControl() const;
8555 
8556 
8558  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
8559 
8561  SegmentKey & UnsetColorInterpolation();
8562 
8564  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8565 
8567  ColorInterpolationControl GetColorInterpolationControl();
8568 
8570  ColorInterpolationControl const GetColorInterpolationControl() const;
8571 
8572 
8574  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8575 
8577  SegmentKey & UnsetContourLine();
8578 
8580  bool ShowContourLine(ContourLineKit & out_kit) const;
8581 
8583  ContourLineControl GetContourLineControl();
8584 
8586  ContourLineControl const GetContourLineControl() const;
8587 
8588 
8590  SegmentKey & SetCulling(CullingKit const & in_kit);
8591 
8593  SegmentKey & UnsetCulling();
8594 
8598  bool ShowCulling(CullingKit & out_kit) const;
8599 
8601  CullingControl GetCullingControl();
8602 
8604  CullingControl const GetCullingControl() const;
8605 
8606 
8608  SegmentKey & SetCurveAttribute(CurveAttributeKit const & in_kit);
8609 
8611  SegmentKey & UnsetCurveAttribute();
8612 
8614  bool ShowCurveAttribute(CurveAttributeKit & out_kit) const;
8615 
8617  CurveAttributeControl GetCurveAttributeControl();
8618 
8620  CurveAttributeControl const GetCurveAttributeControl() const;
8621 
8622 
8624  SegmentKey & SetCuttingSectionAttribute(CuttingSectionAttributeKit const & in_kit);
8625 
8627  SegmentKey & UnsetCuttingSectionAttribute();
8628 
8630  bool ShowCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
8631 
8633  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8634 
8636  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8637 
8638 
8640  SegmentKey & SetCylinderAttribute(CylinderAttributeKit const & in_kit);
8641 
8643  SegmentKey & UnsetCylinderAttribute();
8644 
8646  bool ShowCylinderAttribute(CylinderAttributeKit & out_kit) const;
8647 
8649  CylinderAttributeControl GetCylinderAttributeControl();
8650 
8652  CylinderAttributeControl const GetCylinderAttributeControl() const;
8653 
8654 
8656  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8657 
8659  SegmentKey & UnsetDrawingAttribute();
8660 
8662  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8663 
8665  DrawingAttributeControl GetDrawingAttributeControl();
8666 
8668  DrawingAttributeControl const GetDrawingAttributeControl() const;
8669 
8670 
8672  SegmentKey & SetEdgeAttribute(EdgeAttributeKit const & in_kit);
8673 
8675  SegmentKey & UnsetEdgeAttribute();
8676 
8678  bool ShowEdgeAttribute(EdgeAttributeKit & out_kit) const;
8679 
8681  EdgeAttributeControl GetEdgeAttributeControl();
8682 
8684  EdgeAttributeControl const GetEdgeAttributeControl() const;
8685 
8686 
8688  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8689 
8691  SegmentKey & UnsetHiddenLineAttribute();
8692 
8694  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8695 
8697  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8698 
8700  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8701 
8702 
8704  SegmentKey & SetLightingAttribute(LightingAttributeKit const & in_kit);
8705 
8707  SegmentKey & UnsetLightingAttribute();
8708 
8710  bool ShowLightingAttribute(LightingAttributeKit & out_kit) const;
8711 
8713  LightingAttributeControl GetLightingAttributeControl();
8714 
8716  LightingAttributeControl const GetLightingAttributeControl() const;
8717 
8718 
8720  SegmentKey & SetLineAttribute(LineAttributeKit const & in_kit);
8721 
8723  SegmentKey & UnsetLineAttribute();
8724 
8726  bool ShowLineAttribute(LineAttributeKit & out_kit) const;
8727 
8729  LineAttributeControl GetLineAttributeControl();
8730 
8732  LineAttributeControl const GetLineAttributeControl() const;
8733 
8734 
8736  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8737 
8739  SegmentKey & UnsetMaterialMapping();
8740 
8742  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8743 
8745  SegmentKey & SetPBRMaterial(PBRMaterialKit const & in_kit);
8746 
8748  SegmentKey & UnsetPBRMaterial();
8749 
8751  bool ShowPBRMaterial(PBRMaterialKit & out_kit) const;
8752 
8754  MaterialMappingControl GetMaterialMappingControl();
8755 
8757  MaterialMappingControl const GetMaterialMappingControl() const;
8758 
8759 
8761  SegmentKey & SetMarkerAttribute(MarkerAttributeKit const & in_kit);
8762 
8764  SegmentKey & UnsetMarkerAttribute();
8765 
8767  bool ShowMarkerAttribute(MarkerAttributeKit & out_kit) const;
8768 
8770  MarkerAttributeControl GetMarkerAttributeControl();
8771 
8773  MarkerAttributeControl const GetMarkerAttributeControl() const;
8774 
8775 
8777  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8778 
8780  SegmentKey & UnsetModellingMatrix();
8781 
8783  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8784 
8786  ModellingMatrixControl GetModellingMatrixControl();
8787 
8789  ModellingMatrixControl const GetModellingMatrixControl() const;
8790 
8791 
8793  SegmentKey & SetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit const & in_kit);
8794 
8796  SegmentKey & UnsetNURBSSurfaceAttribute();
8797 
8799  bool ShowNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
8800 
8802  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8803 
8805  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8806 
8807 
8809  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8810 
8812  SegmentKey & UnsetPerformance();
8813 
8815  bool ShowPerformance(PerformanceKit & out_kit) const;
8816 
8818  PerformanceControl GetPerformanceControl();
8819 
8821  PerformanceControl const GetPerformanceControl() const;
8822 
8823 
8825  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8826 
8828  SegmentKey & UnsetSelectability();
8829 
8833  bool ShowSelectability(SelectabilityKit & out_kit) const;
8834 
8836  SelectabilityControl GetSelectabilityControl();
8837 
8839  SelectabilityControl const GetSelectabilityControl() const;
8840 
8841 
8843  SegmentKey & SetSphereAttribute(SphereAttributeKit const & in_kit);
8844 
8846  SegmentKey & UnsetSphereAttribute();
8847 
8850  bool ShowSphereAttribute(SphereAttributeKit & out_kit) const;
8851 
8853  SphereAttributeControl GetSphereAttributeControl();
8854 
8856  SphereAttributeControl const GetSphereAttributeControl() const;
8857 
8858 
8860  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8861 
8863  SegmentKey & UnsetSubwindow();
8864 
8867  bool ShowSubwindow(SubwindowKit & out_kit) const;
8868 
8870  SubwindowControl GetSubwindowControl();
8871 
8873  SubwindowControl const GetSubwindowControl() const;
8874 
8875 
8877  SegmentKey & SetTextAttribute(TextAttributeKit const & in_kit);
8878 
8880  SegmentKey & UnsetTextAttribute();
8881 
8883  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
8884 
8886  TextAttributeControl GetTextAttributeControl();
8887 
8889  TextAttributeControl const GetTextAttributeControl() const;
8890 
8891 
8893  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8894 
8896  SegmentKey & UnsetTextureMatrix();
8897 
8900  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8901 
8903  TextureMatrixControl GetTextureMatrixControl();
8904 
8906  TextureMatrixControl const GetTextureMatrixControl() const;
8907 
8908 
8910  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8911 
8913  SegmentKey & UnsetTransformMask();
8914 
8917  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8918 
8920  TransformMaskControl GetTransformMaskControl();
8921 
8923  TransformMaskControl const GetTransformMaskControl() const;
8924 
8925 
8927  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8928 
8930  SegmentKey & UnsetTransparency();
8931 
8934  bool ShowTransparency(TransparencyKit & out_kit) const;
8935 
8937  TransparencyControl GetTransparencyControl();
8938 
8940  TransparencyControl const GetTransparencyControl() const;
8941 
8942 
8944  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8945 
8947  SegmentKey & UnsetVisibility();
8948 
8951  bool ShowVisibility(VisibilityKit & out_kit) const;
8952 
8954  VisibilityControl GetVisibilityControl();
8955 
8957  VisibilityControl const GetVisibilityControl() const;
8958 
8959 
8961  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8962 
8964  SegmentKey & UnsetVisualEffects();
8965 
8969  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8970 
8972  VisualEffectsControl GetVisualEffectsControl();
8973 
8975  VisualEffectsControl const GetVisualEffectsControl() const;
8976 
8979  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8980 
8981 
8987  OptimizeMappingResults OptimizeWithMapping(SegmentOptimizationOptionsKit const & in_kit);
8988 };
8989 
8990 
8992 class HPS_API SegmentOptimizationOptionsKit : public Kit
8993 {
8994 public:
8995 
8998 
9002 
9006 
9007  virtual ~SegmentOptimizationOptionsKit();
9008 
9009  static const HPS::Type staticType = HPS::Type::SegmentOptimizationOptionsKit;
9010  HPS::Type ObjectType() const { return staticType; }
9011 
9014  void Consume(SegmentOptimizationOptionsKit & in_kit);
9015 
9018  void Set(SegmentOptimizationOptionsKit const & in_kit);
9019 
9022  void Show(SegmentOptimizationOptionsKit & out_kit) const;
9023 
9028 
9033 
9036  bool Empty() const;
9037 
9041  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
9042 
9046  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
9047 
9051  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
9052 
9056  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
9057 
9061  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
9062 
9066  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
9067 
9071  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
9072 
9076  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
9077 
9081  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
9082 
9086  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
9087 
9091  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
9092 
9095  SegmentOptimizationOptionsKit & UnsetUserData();
9096 
9099  SegmentOptimizationOptionsKit & UnsetMatrix();
9100 
9103  SegmentOptimizationOptionsKit & UnsetExpansion();
9104 
9107  SegmentOptimizationOptionsKit & UnsetScope();
9108 
9111  SegmentOptimizationOptionsKit & UnsetReorganization();
9112 
9115  SegmentOptimizationOptionsKit & UnsetShellInstancing();
9116 
9119  SegmentOptimizationOptionsKit & UnsetShellMerging();
9120 
9123  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
9124 
9127  SegmentOptimizationOptionsKit & UnsetEverything();
9128 
9132  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
9133 
9137  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
9138 
9142  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
9143 
9147  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
9148 
9152  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
9153 
9157  bool ShowShellInstancing(bool & out_shell_instancing) const;
9158 
9162  bool ShowShellMerging(bool & out_shell_merging) const;
9163 
9167  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
9168 };
9169 
9170 
9173 class HPS_API UpdateNotifier : public Object
9174 {
9175 public:
9176 
9177  UpdateNotifier();
9178 
9179  UpdateNotifier(UpdateNotifier const & in_that);
9180 
9184  UpdateNotifier(UpdateNotifier && in_that);
9185 
9189  UpdateNotifier & operator=(UpdateNotifier && in_that);
9190 
9191  virtual ~UpdateNotifier();
9192 
9193  static const HPS::Type staticType = HPS::Type::UpdateNotifier;
9194  HPS::Type ObjectType() const {return staticType;};
9195 
9199  UpdateNotifier & operator=(UpdateNotifier const & in_that);
9200 
9203  void Assign(UpdateNotifier const & in_that);
9204 
9207  UpdateNotifier const & Wait() const;
9208 
9212  UpdateNotifier const & Cancel() const;
9213 
9215  Window::UpdateStatus Status() const;
9216 
9217 };
9218 
9221 class HPS_API DriverEvent
9222 {
9223 public:
9224 
9225  virtual ~DriverEvent();
9226 
9228  intptr_t GetClassID() const;
9229 
9230  enum class StereoMatrix
9231  {
9232  ViewLeft,
9233  ViewRight,
9234  ProjectionLeft,
9235  ProjectionRight,
9236  };
9237 
9238  void SetStereoMatrix(StereoMatrix id, HPS::MatrixKit const & in_matrix) const;
9239  OpaqueHandle GetSurface(int index) const;
9240  OpaqueHandle GetGraphicsContext() const;
9241 
9242 protected:
9243 
9244  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
9245  {
9246 
9247  }
9248 
9249  OpaqueHandle nr;
9250 };
9251 
9254 class HPS_API FinishPictureEvent : public DriverEvent
9255 {
9256 public:
9257  FinishPictureEvent(OpaqueHandle in_nr = 0);
9258  virtual ~FinishPictureEvent();
9259 };
9260 
9261 class HPS_API InitPictureEvent : public DriverEvent
9262 {
9263 public:
9264  InitPictureEvent(OpaqueHandle in_nr = 0);
9265  virtual ~InitPictureEvent();
9266 
9267  void SetRenderSurface(OpaqueHandle target) const;
9268 };
9269 
9271 class HPS_API DrawWindowEvent : public DriverEvent
9272 {
9273 public:
9274  DrawWindowEvent(OpaqueHandle in_nr = 0);
9275  virtual ~DrawWindowEvent();
9276 
9279 
9283  {
9284  RGBA,
9285  BGRA,
9286  ImageExternal,
9287  LumaChromaPair
9288  };
9289 
9295  void DrawTexturedBackground(OpaqueHandle in_texture, BackgroundTextureFormat in_format, MatrixKit const & in_matrix, IntRectangle const & in_extent) const;
9296 
9297 private:
9298 
9299  mutable HPS::FloatArray matrix_elements;
9300 };
9301 
9303 class HPS_API DriverEventHandler : public Object
9304 {
9305 public:
9306 
9307  static const HPS::Type staticType = HPS::Type::DriverEventHandler;
9308  HPS::Type ObjectType() const override { return staticType; };
9309 
9311 
9312  DriverEventHandler(DriverEventHandler const & that);
9313 
9314  virtual ~DriverEventHandler();
9315 
9319  virtual void Handle(DriverEvent const * in_event)
9320  {
9321  HPS_UNREFERENCED(in_event);
9322  }
9323 };
9324 
9325 
9326 
9327 
9331 class HPS_API WindowKey : public SegmentKey
9332 {
9333 public:
9334 
9336  WindowKey();
9337 
9339  WindowKey(WindowKey const & in_window);
9340 
9342  WindowKey & operator=(WindowKey const & other);
9343 
9347  WindowKey(WindowKey && in_that);
9348 
9352  WindowKey & operator=(WindowKey && in_that);
9353 
9355  WindowKey(Key const & in_key);
9356 
9358  ~WindowKey();
9359 
9360  static const HPS::Type staticType = HPS::Type::WindowKey;
9361  HPS::Type ObjectType() const {return staticType;};
9362 
9364  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9365 
9370  size_t FindFonts(FontSearchResults & out_results) const;
9371 
9376  size_t FindHighlights(HighlightSearchOptionsKit const & in_options, HighlightSearchResults & out_results) const;
9377 
9384  size_t FindHighlights(KeyPath const & in_key_path, HPS::HighlightSearch::Scope in_scope, HighlightSearchOptionsKit const & in_options, HighlightSearchResults & out_results) const;
9385 
9387  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
9388 
9390  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
9391 
9393  PostProcessEffectsControl GetPostProcessEffectsControl();
9394 
9396  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
9397 
9398 
9400  WindowKey & SetDebugging(DebuggingKit const & in_kit);
9401 
9405  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
9406 
9409  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
9410 
9414  bool ShowDebugging(DebuggingKit & out_kit) const;
9415 
9417  DebuggingControl GetDebuggingControl();
9418 
9420  DebuggingControl const GetDebuggingControl() const;
9421 
9423  WindowInfoControl const GetWindowInfoControl() const;
9424 
9425  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
9426 
9428  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
9429 
9431  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
9432 
9434  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
9435 
9437  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
9438 
9439 
9441  SelectionOptionsControl GetSelectionOptionsControl();
9442 
9444  SelectionOptionsControl const GetSelectionOptionsControl() const;
9445 
9446 
9448  SelectionControl GetSelectionControl();
9449 
9451  SelectionControl const GetSelectionControl() const;
9452 
9454  HighlightControl GetHighlightControl();
9455 
9457  HighlightControl const GetHighlightControl() const;
9458 
9460  UpdateOptionsControl GetUpdateOptionsControl();
9461 
9463  UpdateOptionsControl const GetUpdateOptionsControl() const;
9464 
9466  void Update();
9467 
9472  void Update(UpdateOptionsKit const & in_kit);
9473 
9488  void Update(Window::UpdateType in_type, Time in_time_limit=-1);
9489 
9493  UpdateNotifier UpdateWithNotifier();
9494 
9498  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
9499 
9505  UpdateNotifier UpdateWithNotifier(Window::UpdateType in_type, Time in_time_limit=-1);
9506 
9508  EventDispatcher & GetEventDispatcher();
9509 
9511  EventDispatcher const & GetEventDispatcher() const;
9512 
9516  bool ShowSnapshot(ImageKit & out_kit) const;
9517 
9518 private:
9519 
9521  SegmentKey & UnsetAttributeLock();
9522  SegmentKey & UnsetCamera();
9523  SegmentKey & UnsetColorInterpolation();
9524  SegmentKey & UnsetContourLine();
9525  SegmentKey & UnsetCulling();
9526  SegmentKey & UnsetCurveAttribute();
9527  SegmentKey & UnsetCuttingSectionAttribute();
9528  SegmentKey & UnsetCylinderAttribute();
9529  SegmentKey & UnsetDrawingAttribute();
9530  SegmentKey & UnsetEdgeAttribute();
9531  SegmentKey & UnsetHiddenLineAttribute();
9532  SegmentKey & UnsetLightingAttribute();
9533  SegmentKey & UnsetLineAttribute();
9534  SegmentKey & UnsetMaterialMapping();
9535  SegmentKey & UnsetMarkerAttribute();
9536  SegmentKey & UnsetModellingMatrix();
9537  SegmentKey & UnsetNURBSSurfaceAttribute();
9538  SegmentKey & UnsetPerformance();
9539  SegmentKey & UnsetSelectability();
9540  SegmentKey & UnsetSphereAttribute();
9541  SegmentKey & UnsetSubwindow();
9542  SegmentKey & UnsetTextAttribute();
9543  SegmentKey & UnsetTextureMatrix();
9544  SegmentKey & UnsetTransformMask();
9545  SegmentKey & UnsetTransparency();
9546  SegmentKey & UnsetVisibility();
9547  SegmentKey & UnsetVisualEffects();
9548 
9550  void MoveTo(SegmentKey const & in_new_owner);
9551 
9553  Key CopyTo(SegmentKey const & in_destination) const;
9554 };
9555 
9556 
9557 
9560 class HPS_API KeyPath : public Object
9561 {
9562 public:
9563 
9565  KeyPath();
9566 
9569  KeyPath(KeyArray const & in_path);
9570 
9574  KeyPath(size_t in_path_count, Key const in_path []);
9575 
9577  KeyPath(KeyPath const & in_that);
9578 
9582  KeyPath(KeyPath && in_that);
9583 
9587  KeyPath & operator=(KeyPath && in_that);
9588 
9590  virtual ~KeyPath();
9591 
9592  static const HPS::Type staticType = HPS::Type::KeyPath;
9593  HPS::Type ObjectType() const { return staticType; }
9594 
9598  KeyPath & operator+=(Key const & in_key);
9599 
9603  KeyPath & operator+=(KeyPath const & in_key_path);
9604 
9608  KeyPath & operator+=(KeyArray const & in_key_array);
9609 
9614  KeyPath & Append(Key const & in_key);
9615 
9620  KeyPath & Append(KeyPath const & in_key_path);
9621 
9626  KeyPath & Append(KeyArray const & in_key_array);
9627 
9631  KeyPath & operator=(KeyPath const & in_that);
9632 
9636  KeyPath & operator=(KeyArray const & in_path);
9637 
9640  void Set(KeyPath const & in_that);
9641 
9645  bool Equals(KeyPath const & in_that) const;
9646 
9650  bool operator!= (KeyPath const & in_that) const;
9651 
9655  bool operator== (KeyPath const & in_that) const;
9656 
9657 
9661  KeyPath & SetKeys(KeyArray const & in_keys);
9662 
9667  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9668 
9669 
9672  KeyPath & UnsetKeys();
9673 
9674 
9677  bool ShowKeys(KeyArray & out_keys) const;
9678 
9679 
9686  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9687 
9694  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9695 
9703  bool ComputeTextExtent(char const * in_text, float & out_xfrac, float & out_yfrac) const;
9704 
9710  bool ComputeExtent(Rectangle & out_extent) const;
9711 
9718  bool ComputeExtent(HPS::VisibilityKit const & in_vis, Rectangle & out_extent) const;
9719 
9720 
9727  bool ComputeExtent(HPS::Extent::ClipRegion in_clip, Rectangle & out_extent) const;
9728 
9729 
9737  bool ComputeExtent(HPS::VisibilityKit const & in_vis, HPS::Extent::ClipRegion in_clip, Rectangle & out_extent) const;
9738 
9744  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9745 
9748  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9749 
9753  bool ShowNetBounding(BoundingKit & out_kit) const;
9754 
9759  bool ShowNetBounding(bool in_consider_highlights, BoundingKit & out_kit) const;
9760 
9763  bool ShowNetCamera(CameraKit & out_kit) const;
9764 
9767  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9768 
9771  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9772 
9775  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9776 
9779  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9780 
9783  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9784 
9787  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9788 
9791  bool ShowNetMarkerAttribute(MarkerAttributeKit & out_kit) const;
9792 
9795  bool ShowNetSphereAttribute(SphereAttributeKit & out_kit) const;
9796 
9799  bool ShowNetLightingAttribute(LightingAttributeKit & out_kit) const;
9800 
9803  bool ShowNetCylinderAttribute(CylinderAttributeKit & out_kit) const;
9804 
9807  bool ShowNetCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
9808 
9811  bool ShowNetTextAttribute(TextAttributeKit & out_kit) const;
9812 
9815  bool ShowNetLineAttribute(LineAttributeKit & out_kit) const;
9816 
9819  bool ShowNetEdgeAttribute(EdgeAttributeKit & out_kit) const;
9820 
9823  bool ShowNetCurveAttribute(CurveAttributeKit & out_kit) const;
9824 
9827  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9828 
9831  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9832 
9835  bool ShowNetCulling(CullingKit & out_kit) const;
9836 
9839  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9840 
9843  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9844 
9847  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9848 
9851  bool ShowNetPBRMaterial(PBRMaterialKit & out_kit) const;
9852 
9855  bool ShowNetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
9856 
9859  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9860 
9863  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9864 
9867  bool ShowNetAttributeLock(AttributeLockKit & out_kit) const;
9868 
9871  bool ShowNetConditions(UTF8Array & out_conditions) const;
9872 
9878  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9879 
9880 
9887  bool ShowNetClipRegions(PointArrayArrayArray & out_loops_array, ClipSpaceArray & out_spaces, ClipOperationArray & out_operations, MatrixKitArray & out_matrices) const;
9888 
9891  bool ShowNetMaterialPalette(UTF8 & out_name) const;
9892 
9897  bool ShowEffectiveMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_def) const;
9898 
9903  bool ShowEffectiveGlyphDefinition(char const * in_name, GlyphDefinition & out_def) const;
9904 
9909  bool ShowEffectiveLinePatternDefinition(char const * in_name, LinePatternDefinition & out_def) const;
9910 
9915  bool ShowEffectiveShaderDefinition(char const * in_name, ShaderDefinition & out_def) const;
9916 
9921  bool ShowEffectiveTextureDefinition(char const * in_name, TextureDefinition & out_def) const;
9922 
9927  bool ShowEffectiveImageDefinition(char const * in_name, ImageDefinition & out_def) const;
9928 
9931  size_t Size() const;
9932 
9935  virtual bool Empty() const;
9936 
9940  Key & At(size_t in_index);
9941 
9945  Key const & At(size_t in_index) const;
9946 
9951  void Insert(size_t in_index, Key const & in_item);
9952 
9956  void Remove(Key const & in_item);
9957 
9960  void Remove(size_t in_index);
9961 
9964  KeyPath Reverse() const;
9965 
9968  Key & Front();
9969 
9972  Key const & Front() const;
9973 
9976  Key & Back();
9977 
9980  Key const & Back() const;
9981 
9984  Key PopFront();
9985 
9988  Key PopBack();
9989 
9993  KeyPath & PushFront(Key const & in_key);
9994 
9998  KeyPath & PushBack(Key const & in_key);
9999 
10003  KeyPath & PushBack(KeyPath const & in_key_path);
10004 
10008  KeyPath & PushBack(KeyArray const & in_key_array);
10009 
10010 #ifndef HPS_GULP_CLANG
10011  using iterator = HPS::KeyArray::iterator;
10012  using const_iterator = HPS::KeyArray::const_iterator;
10013  using reverse_iterator = HPS::KeyArray::reverse_iterator;
10014  using const_reverse_iterator = HPS::KeyArray::const_reverse_iterator;
10015 
10018  iterator begin();
10019 
10022  const_iterator begin() const;
10023 
10026  iterator end();
10027 
10030  const_iterator end() const;
10031 
10034  const_iterator cbegin() const;
10035 
10038  const_iterator cend() const;
10039 
10040  /* Returns a reverse iterator pointing to the last Key contained in this Key Path
10041  * \return A reverse iterator pointing to the last Key contained in this Key Path. */
10042  reverse_iterator rbegin();
10043 
10044  /* Returns a reverse iterator pointing to the first Key contained in this Key Path
10045  * \return A reverse iterator pointing to the first Key contained in this Key Path. */
10046  reverse_iterator rend();
10047 
10048  /* Returns a constant reverse iterator pointing to the last Key contained in this Key Path
10049  * \return A constant reverse iterator pointing to the last Key contained in this Key Path. */
10050  const_reverse_iterator rbegin() const;
10051 
10052  /* Returns a constant iterator pointing to the first Key contained in this Key Path
10053  * \return A constant iterator pointing to the first Key contained in this Key Path. */
10054  const_reverse_iterator rend() const;
10055 #endif
10056 };
10057 
10062 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
10063 {
10064  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10065 }
10066 
10071 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
10072 {
10073  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10074 }
10075 
10080 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
10081 {
10082  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10083 }
10084 
10089 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
10090 {
10091  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10092 }
10093 
10098 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
10099 {
10100  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10101 }
10102 
10107 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
10108 {
10109  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10110 }
10111 
10116 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
10117 {
10118  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10119 }
10120 
10125 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
10126 {
10127  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10128 }
10129 
10134 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
10135 {
10136  return HPS::KeyPath().PushBack(in_lhs).PushBack(in_rhs);
10137 }
10138 
10139 
10143 
10145 class HPS_API BoundingKit : public Kit
10146 {
10147 public:
10148 
10150  BoundingKit();
10151 
10154  BoundingKit(BoundingKit const & in_kit);
10155 
10159  BoundingKit(BoundingKit && in_that);
10160 
10164  BoundingKit & operator=(BoundingKit && in_that);
10165 
10167  virtual ~BoundingKit();
10168 
10169  static const HPS::Type staticType = HPS::Type::BoundingKit;
10170  HPS::Type ObjectType() const {return staticType;};
10171 
10175  static BoundingKit GetDefault();
10176 
10179  void Set(BoundingKit const & in_kit);
10180 
10183  void Show(BoundingKit & out_kit) const;
10184 
10188  BoundingKit & operator=(BoundingKit const & in_kit);
10189 
10192  bool Empty() const;
10193 
10197  bool Equals(BoundingKit const & in_kit) const;
10198 
10202  bool operator==(BoundingKit const & in_kit) const;
10203 
10207  bool operator!=(BoundingKit const & in_kit) const;
10208 
10209 
10213  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
10214 
10218  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
10219 
10223  BoundingKit & SetExclusion(bool in_exclude);
10224 
10225 
10228  BoundingKit & UnsetVolume();
10229 
10232  BoundingKit & UnsetExclusion();
10233 
10236  BoundingKit & UnsetEverything();
10237 
10238 
10243  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
10244 
10248  bool ShowExclusion(bool & out_exclusion) const;
10249 
10250 };
10251 
10252 
10255 class HPS_API BoundingControl : public Control
10256 {
10257 public:
10258 
10260  explicit BoundingControl(SegmentKey & in_seg);
10261 
10263  BoundingControl(BoundingControl const & in_that);
10264 
10268  BoundingControl(BoundingControl && in_that);
10269 
10273  BoundingControl & operator=(BoundingControl && in_that);
10274 
10276  ~BoundingControl();
10277 
10278  virtual HPS::Type Type() const { return ObjectType(); }
10279 
10280  static const HPS::Type staticType = HPS::Type::BoundingControl;
10281  HPS::Type ObjectType() const {return staticType;};
10282 
10286  BoundingControl & operator=(BoundingControl const & in_that);
10287 
10292  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
10293 
10297  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
10298 
10302  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
10303 
10307  BoundingControl & SetExclusion(bool in_exclusion);
10308 
10309 
10313  BoundingControl & UnsetVolume();
10314 
10318  BoundingControl & UnsetExclusion();
10319 
10323  BoundingControl & UnsetEverything();
10324 
10325 
10330  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
10331 
10335  bool ShowExclusion(bool & out_exclusion) const;
10336 
10337 private:
10339  BoundingControl();
10340 };
10341 
10342 
10344 class HPS_API VisibilityKit : public Kit
10345 {
10346 public:
10347 
10349  VisibilityKit();
10350 
10353  VisibilityKit(VisibilityKit const & in_kit);
10354 
10358  VisibilityKit(VisibilityKit && in_that);
10359 
10363  VisibilityKit & operator=(VisibilityKit && in_that);
10364 
10366  virtual ~VisibilityKit();
10367 
10368  static const HPS::Type staticType = HPS::Type::VisibilityKit;
10369  HPS::Type ObjectType() const {return staticType;};
10370 
10374  static VisibilityKit GetDefault();
10375 
10378  void Set(VisibilityKit const & in_kit);
10379 
10382  void Show(VisibilityKit & out_kit) const;
10383 
10387  VisibilityKit & operator=(VisibilityKit const & in_kit);
10388 
10391  bool Empty() const;
10392 
10396  bool Equals(VisibilityKit const & in_kit) const;
10397 
10401  bool operator==(VisibilityKit const & in_kit) const;
10402 
10406  bool operator!=(VisibilityKit const & in_kit) const;
10407 
10408 
10412  VisibilityKit & SetCuttingSections(bool in_state);
10413 
10417  VisibilityKit & SetCutEdges(bool in_state);
10418 
10422  VisibilityKit & SetCutFaces(bool in_state);
10423 
10427  VisibilityKit & SetWindows(bool in_state);
10428 
10432  VisibilityKit & SetText(bool in_state);
10433 
10437  VisibilityKit & SetLines(bool in_state);
10438 
10442  VisibilityKit & SetEdgeLights(bool in_state);
10443 
10447  VisibilityKit & SetMarkerLights(bool in_state);
10448 
10452  VisibilityKit & SetFaceLights(bool in_state);
10453 
10457  VisibilityKit & SetGenericEdges(bool in_state);
10458 
10462  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
10463 
10470  VisibilityKit & SetAdjacentEdges(bool in_state);
10471 
10475  VisibilityKit & SetHardEdges(bool in_state);
10476 
10480  VisibilityKit & SetMeshQuadEdges(bool in_state);
10481 
10485  VisibilityKit & SetNonCulledEdges(bool in_state);
10486 
10490  VisibilityKit & SetPerimeterEdges(bool in_state);
10491 
10495  VisibilityKit & SetFaces(bool in_state);
10496 
10500  VisibilityKit & SetVertices(bool in_state);
10501 
10505  VisibilityKit & SetMarkers(bool in_state);
10506 
10510  VisibilityKit & SetShadowCasting(bool in_state);
10511 
10515  VisibilityKit & SetShadowReceiving(bool in_state);
10516 
10520  VisibilityKit & SetShadowEmitting(bool in_state);
10521 
10522 
10526  VisibilityKit & SetCutGeometry(bool in_state);
10527 
10531  VisibilityKit & SetEdges(bool in_state);
10532 
10536  VisibilityKit & SetGeometry(bool in_state);
10537 
10541  VisibilityKit & SetLights(bool in_state);
10542 
10546  VisibilityKit & SetShadows(bool in_state);
10547 
10551  VisibilityKit & SetLeaderLines(bool in_state);
10552 
10556  VisibilityKit & SetEverything(bool in_state);
10557 
10558 
10561  VisibilityKit & UnsetCuttingSections();
10562 
10565  VisibilityKit & UnsetCutEdges();
10566 
10569  VisibilityKit & UnsetCutFaces();
10570 
10573  VisibilityKit & UnsetWindows();
10574 
10577  VisibilityKit & UnsetText();
10578 
10581  VisibilityKit & UnsetLines();
10582 
10585  VisibilityKit & UnsetEdgeLights();
10586 
10589  VisibilityKit & UnsetMarkerLights();
10590 
10593  VisibilityKit & UnsetFaceLights();
10594 
10597  VisibilityKit & UnsetGenericEdges();
10598 
10601  VisibilityKit & UnsetInteriorSilhouetteEdges();
10602 
10605  VisibilityKit & UnsetAdjacentEdges();
10606 
10609  VisibilityKit & UnsetHardEdges();
10610 
10613  VisibilityKit & UnsetMeshQuadEdges();
10614 
10617  VisibilityKit & UnsetNonCulledEdges();
10618 
10621  VisibilityKit & UnsetPerimeterEdges();
10622 
10625  VisibilityKit & UnsetFaces();
10626 
10629  VisibilityKit & UnsetVertices();
10630 
10633  VisibilityKit & UnsetMarkers();
10634 
10637  VisibilityKit & UnsetShadowCasting();
10638 
10641  VisibilityKit & UnsetShadowReceiving();
10642 
10645  VisibilityKit & UnsetShadowEmitting();
10646 
10647 
10650  VisibilityKit & UnsetCutGeometry();
10651 
10654  VisibilityKit & UnsetEdges();
10655 
10658  VisibilityKit & UnsetGeometry();
10659 
10662  VisibilityKit & UnsetLights();
10663 
10666  VisibilityKit & UnsetShadows();
10667 
10670  VisibilityKit & UnsetLeaderLines();
10671 
10674  VisibilityKit & UnsetEverything();
10675 
10676 
10680  bool ShowCuttingSections(bool & out_state) const;
10681 
10685  bool ShowCutEdges(bool & out_state) const;
10686 
10690  bool ShowCutFaces(bool & out_state) const;
10691 
10695  bool ShowWindows(bool & out_state) const;
10696 
10700  bool ShowText(bool & out_state) const;
10701 
10705  bool ShowLines(bool & out_state) const;
10706 
10710  bool ShowEdgeLights(bool & out_state) const;
10711 
10715  bool ShowMarkerLights(bool & out_state) const;
10716 
10720  bool ShowFaceLights(bool & out_state) const;
10721 
10725  bool ShowGenericEdges(bool & out_state) const;
10726 
10730  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10731 
10735  bool ShowAdjacentEdges(bool & out_state) const;
10736 
10740  bool ShowHardEdges(bool & out_state) const;
10741 
10745  bool ShowMeshQuadEdges(bool & out_state) const;
10746 
10750  bool ShowNonCulledEdges(bool & out_state) const;
10751 
10755  bool ShowPerimeterEdges(bool & out_state) const;
10756 
10760  bool ShowFaces(bool & out_state) const;
10761 
10765  bool ShowVertices(bool & out_state) const;
10766 
10770  bool ShowMarkers(bool & out_state) const;
10771 
10775  bool ShowShadowCasting(bool & out_state) const;
10776 
10780  bool ShowShadowReceiving(bool & out_state) const;
10781 
10785  bool ShowShadowEmitting(bool & out_state) const;
10786 
10790  bool ShowLeaderLines(bool & out_state) const;
10791 };
10792 
10793 
10799 class HPS_API VisibilityControl : public Control
10800 {
10801 public:
10802 
10804  explicit VisibilityControl(SegmentKey & in_seg);
10805 
10807  VisibilityControl(VisibilityControl const & in_that);
10808 
10813 
10817  VisibilityControl & operator=(VisibilityControl && in_that);
10818 
10820  ~VisibilityControl();
10821 
10822  virtual HPS::Type Type() const { return ObjectType(); }
10823 
10824  static const HPS::Type staticType = HPS::Type::VisibilityControl;
10825  HPS::Type ObjectType() const {return staticType;};
10826 
10830  VisibilityControl & operator=(VisibilityControl const & in_that);
10831 
10835  VisibilityControl & SetCuttingSections(bool in_state);
10836 
10840  VisibilityControl & SetCutEdges(bool in_state);
10841 
10845  VisibilityControl & SetCutFaces(bool in_state);
10846 
10850  VisibilityControl & SetWindows(bool in_state);
10851 
10855  VisibilityControl & SetText(bool in_state);
10856 
10860  VisibilityControl & SetLines(bool in_state);
10861 
10865  VisibilityControl & SetEdgeLights(bool in_state);
10866 
10870  VisibilityControl & SetMarkerLights(bool in_state);
10871 
10875  VisibilityControl & SetFaceLights(bool in_state);
10876 
10880  VisibilityControl & SetGenericEdges(bool in_state);
10881 
10885  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
10886 
10890  VisibilityControl & SetAdjacentEdges(bool in_state);
10891 
10895  VisibilityControl & SetHardEdges(bool in_state);
10896 
10900  VisibilityControl & SetMeshQuadEdges(bool in_state);
10901 
10905  VisibilityControl & SetNonCulledEdges(bool in_state);
10906 
10910  VisibilityControl & SetPerimeterEdges(bool in_state);
10911 
10915  VisibilityControl & SetFaces(bool in_state);
10916 
10920  VisibilityControl & SetVertices(bool in_state);
10921 
10925  VisibilityControl & SetMarkers(bool in_state);
10926 
10930  VisibilityControl & SetShadowCasting(bool in_state);
10931 
10935  VisibilityControl & SetShadowReceiving(bool in_state);
10936 
10940  VisibilityControl & SetShadowEmitting(bool in_state);
10941 
10942 
10946  VisibilityControl & SetCutGeometry(bool in_state);
10947 
10951  VisibilityControl & SetEdges(bool in_state);
10952 
10956  VisibilityControl & SetGeometry(bool in_state);
10957 
10961  VisibilityControl & SetLights(bool in_state);
10962 
10966  VisibilityControl & SetShadows(bool in_state);
10967 
10971  VisibilityControl & SetLeaderLines(bool in_state);
10972 
10976  VisibilityControl & SetEverything(bool in_state);
10977 
10978 
10982  VisibilityControl & UnsetCuttingSections();
10983 
10987  VisibilityControl & UnsetCutEdges();
10988 
10992  VisibilityControl & UnsetCutFaces();
10993 
10997  VisibilityControl & UnsetWindows();
10998 
11002  VisibilityControl & UnsetText();
11003 
11007  VisibilityControl & UnsetLines();
11008 
11012  VisibilityControl & UnsetEdgeLights();
11013 
11017  VisibilityControl & UnsetMarkerLights();
11018 
11022  VisibilityControl & UnsetFaceLights();
11023 
11027  VisibilityControl & UnsetGenericEdges();
11028 
11032  VisibilityControl & UnsetInteriorSilhouetteEdges();
11033 
11037  VisibilityControl & UnsetAdjacentEdges();
11038 
11042  VisibilityControl & UnsetHardEdges();
11043 
11047  VisibilityControl & UnsetMeshQuadEdges();
11048 
11052  VisibilityControl & UnsetNonCulledEdges();
11053 
11057  VisibilityControl & UnsetPerimeterEdges();
11058 
11062  VisibilityControl & UnsetFaces();
11063 
11067  VisibilityControl & UnsetVertices();
11068 
11072  VisibilityControl & UnsetMarkers();
11073 
11077  VisibilityControl & UnsetShadowCasting();
11078 
11082  VisibilityControl & UnsetShadowReceiving();
11083 
11087  VisibilityControl & UnsetShadowEmitting();
11088 
11089 
11093  VisibilityControl & UnsetCutGeometry();
11094 
11098  VisibilityControl & UnsetEdges();
11099 
11103  VisibilityControl & UnsetGeometry();
11104 
11108  VisibilityControl & UnsetLights();
11109 
11113  VisibilityControl & UnsetShadows();
11114 
11118  VisibilityControl & UnsetLeaderLines();
11119 
11123  VisibilityControl & UnsetEverything();
11124 
11125 
11129  bool ShowCuttingSections(bool & out_state) const;
11130 
11134  bool ShowCutEdges(bool & out_state) const;
11135 
11139  bool ShowCutFaces(bool & out_state) const;
11140 
11144  bool ShowWindows(bool & out_state) const;
11145 
11149  bool ShowText(bool & out_state) const;
11150 
11154  bool ShowLines(bool & out_state) const;
11155 
11159  bool ShowEdgeLights(bool & out_state) const;
11160 
11164  bool ShowMarkerLights(bool & out_state) const;
11165 
11169  bool ShowFaceLights(bool & out_state) const;
11170 
11174  bool ShowGenericEdges(bool & out_state) const;
11175 
11179  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
11180 
11184  bool ShowAdjacentEdges(bool & out_state) const;
11185 
11189  bool ShowHardEdges(bool & out_state) const;
11190 
11194  bool ShowMeshQuadEdges(bool & out_state) const;
11195 
11199  bool ShowNonCulledEdges(bool & out_state) const;
11200 
11204  bool ShowPerimeterEdges(bool & out_state) const;
11205 
11209  bool ShowFaces(bool & out_state) const;
11210 
11214  bool ShowVertices(bool & out_state) const;
11215 
11219  bool ShowMarkers(bool & out_state) const;
11220 
11224  bool ShowShadowCasting(bool & out_state) const;
11225 
11229  bool ShowShadowReceiving(bool & out_state) const;
11230 
11234  bool ShowShadowEmitting(bool & out_state) const;
11235 
11239  bool ShowLeaderLines(bool & out_state) const;
11240 
11241 private:
11244 };
11245 
11246 
11247 
11250 class HPS_API CameraKit : public Kit
11251 {
11252 public:
11253 
11255  CameraKit();
11256 
11259  CameraKit(const CameraKit & in_kit);
11260 
11264  CameraKit(CameraKit && in_that);
11265 
11269  CameraKit & operator=(CameraKit && in_that);
11270 
11272  virtual ~CameraKit();
11273 
11274  static const HPS::Type staticType = HPS::Type::CameraKit;
11275  HPS::Type ObjectType() const {return staticType;};
11276 
11280  static CameraKit GetDefault();
11281 
11284  void Set(CameraKit const & in_kit);
11285 
11288  void Show(CameraKit & out_kit) const;
11289 
11293  CameraKit & operator=(CameraKit const & in_kit);
11294 
11297  bool Empty() const;
11298 
11302  bool Equals(CameraKit const & in_kit) const;
11303 
11307  bool operator==(CameraKit const & in_kit) const;
11308 
11312  bool operator!=(CameraKit const & in_kit) const;
11313 
11317  CameraKit & SetUpVector(Vector const & in_up);
11318 
11322  CameraKit & SetPosition(Point const & in_position);
11323 
11327  CameraKit & SetTarget(Point const & in_target);
11328 
11335  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
11336 
11342  CameraKit & SetField(float in_width, float in_height);
11343 
11353  CameraKit & SetNearLimit(float const in_limit);
11354 
11357  CameraKit & UnsetUpVector();
11358 
11361  CameraKit & UnsetPosition();
11362 
11365  CameraKit & UnsetTarget();
11366 
11369  CameraKit & UnsetProjection();
11370 
11373  CameraKit & UnsetField();
11374 
11377  CameraKit & UnsetNearLimit();
11378 
11381  CameraKit & UnsetEverything();
11382 
11383 
11387  bool ShowUpVector(Vector & out_up_vector) const;
11388 
11392  bool ShowPosition(Point & out_position) const;
11393 
11397  bool ShowTarget(Point & out_target) const;
11398 
11402  bool ShowProjection(Camera::Projection & out_type) const;
11403 
11409  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
11410 
11414  bool ShowWidth(float & out_width) const;
11415 
11419  bool ShowHeight(float & out_height) const;
11420 
11425  bool ShowField(float & out_width, float & out_height) const;
11426 
11430  bool ShowNearLimit(float & out_near_limit) const;
11431 
11438  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
11439 
11446  CameraKit & Orbit(float in_theta, float in_phi);
11447 
11454  CameraKit & Pan(float in_theta, float in_phi);
11455 
11461  CameraKit & Roll(float in_theta);
11462 
11468  CameraKit & Zoom(float in_zoom);
11469 };
11470 
11474 class HPS_API CameraControl : public Control
11475 {
11476 public:
11478  explicit CameraControl(SegmentKey & in_seg);
11479 
11481  CameraControl(CameraControl const & in_that);
11482 
11486  CameraControl(CameraControl && in_that);
11487 
11491  CameraControl & operator=(CameraControl && in_that);
11492 
11494  ~CameraControl();
11495 
11496  virtual HPS::Type Type() const { return ObjectType(); }
11497 
11498  static const HPS::Type staticType = HPS::Type::CameraControl;
11499  HPS::Type ObjectType() const {return staticType;};
11500 
11504  CameraControl & operator=(CameraControl const & in_that);
11505 
11510  CameraControl & SetUpVector(Vector const & in_up);
11511 
11516  CameraControl & SetPosition(Point const & in_position);
11517 
11522  CameraControl & SetTarget(Point const & in_target);
11523 
11530  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
11531 
11537  CameraControl & SetField(float in_width, float in_height);
11538 
11549  CameraControl & SetNearLimit(float in_double);
11550 
11555  CameraControl & UnsetEverything();
11556 
11557 
11561  bool ShowUpVector(Vector & out_up_vector) const;
11562 
11566  bool ShowPosition(Point & out_position) const;
11567 
11571  bool ShowTarget(Point & out_target) const;
11572 
11576  bool ShowProjection(Camera::Projection & out_type) const;
11577 
11583  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
11584 
11588  bool ShowWidth(float & out_width) const;
11589 
11593  bool ShowHeight(float & out_height) const;
11594 
11599  bool ShowField(float & out_width, float & out_height) const;
11600 
11604  bool ShowNearLimit(float & out_near_limit) const;
11605 
11612  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
11613 
11620  CameraControl & Orbit(float in_theta, float in_phi);
11621 
11628  CameraControl & Pan(float in_theta, float in_phi);
11629 
11635  CameraControl & Roll(float in_theta);
11636 
11642  CameraControl & Zoom(float in_zoom);
11643 
11644 private:
11646  CameraControl();
11647 };
11648 
11649 
11650 
11652 class HPS_API SelectabilityKit : public Kit
11653 {
11654 public:
11655 
11657  SelectabilityKit();
11658 
11661  SelectabilityKit(SelectabilityKit const & in_kit);
11662 
11666  SelectabilityKit(SelectabilityKit && in_that);
11667 
11671  SelectabilityKit & operator=(SelectabilityKit && in_that);
11672 
11674  virtual ~SelectabilityKit();
11675 
11676  static const HPS::Type staticType = HPS::Type::SelectabilityKit;
11677  HPS::Type ObjectType() const {return staticType;};
11678 
11682  static SelectabilityKit GetDefault();
11683 
11686  void Set(SelectabilityKit const & in_kit);
11687 
11690  void Show(SelectabilityKit & out_kit) const;
11691 
11695  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
11696 
11699  bool Empty() const;
11700 
11704  bool Equals(SelectabilityKit const & in_kit) const;
11705 
11709  bool operator==(SelectabilityKit const & in_kit) const;
11710 
11714  bool operator!=(SelectabilityKit const & in_kit) const;
11715 
11716 
11720  SelectabilityKit & SetWindows(Selectability::Value in_val);
11721 
11725  SelectabilityKit & SetWindows(bool in_val);
11726 
11730  SelectabilityKit & SetEdges(Selectability::Value in_val);
11731 
11735  SelectabilityKit & SetEdges(bool in_val);
11736 
11740  SelectabilityKit & SetFaces(Selectability::Value in_val);
11741 
11745  SelectabilityKit & SetFaces(bool in_val);
11746 
11750  SelectabilityKit & SetLights(Selectability::Value in_val);
11751 
11755  SelectabilityKit & SetLights(bool in_val);
11756 
11760  SelectabilityKit & SetLines(Selectability::Value in_val);
11761 
11765  SelectabilityKit & SetLines(bool in_val);
11766 
11770  SelectabilityKit & SetMarkers(Selectability::Value in_val);
11771 
11775  SelectabilityKit & SetMarkers(bool in_val);
11776 
11780  SelectabilityKit & SetVertices(Selectability::Value in_val);
11781 
11785  SelectabilityKit & SetVertices(bool in_val);
11786 
11790  SelectabilityKit & SetText(Selectability::Value in_val);
11791 
11795  SelectabilityKit & SetText(bool in_val);
11796 
11800  SelectabilityKit & SetGeometry(Selectability::Value in_val);
11801 
11805  SelectabilityKit & SetGeometry(bool in_val);
11806 
11810  SelectabilityKit & SetEverything(Selectability::Value in_val);
11811 
11815  SelectabilityKit & SetEverything(bool in_val);
11816 
11817 
11820  SelectabilityKit & UnsetWindows();
11821 
11824  SelectabilityKit & UnsetEdges();
11825 
11828  SelectabilityKit & UnsetFaces();
11829 
11832  SelectabilityKit & UnsetLights();
11833 
11836  SelectabilityKit & UnsetLines();
11837 
11840  SelectabilityKit & UnsetMarkers();
11841 
11844  SelectabilityKit & UnsetVertices();
11845 
11848  SelectabilityKit & UnsetText();
11849 
11852  SelectabilityKit & UnsetGeometry();
11853 
11856  SelectabilityKit & UnsetEverything();
11857 
11858 
11862  bool ShowWindows(Selectability::Value & out_val) const;
11863 
11867  bool ShowEdges(Selectability::Value & out_val) const;
11868 
11872  bool ShowFaces(Selectability::Value & out_val) const;
11873 
11877  bool ShowLights(Selectability::Value & out_val) const;
11878 
11882  bool ShowLines(Selectability::Value & out_val) const;
11883 
11887  bool ShowMarkers(Selectability::Value & out_val) const;
11888 
11892  bool ShowVertices(Selectability::Value & out_val) const;
11893 
11897  bool ShowText(Selectability::Value & out_val) const;
11898 };
11899 
11905 class HPS_API SelectabilityControl : public Control
11906 {
11907 public:
11908 
11910  explicit SelectabilityControl(SegmentKey & in_seg);
11911 
11913  SelectabilityControl(SelectabilityControl const & in_that);
11914 
11919 
11923  SelectabilityControl & operator=(SelectabilityControl && in_that);
11924 
11927 
11928  virtual HPS::Type Type() const { return ObjectType(); }
11929 
11930  static const HPS::Type staticType = HPS::Type::SelectabilityControl;
11931  HPS::Type ObjectType() const {return staticType;};
11932 
11936  SelectabilityControl & operator=(SelectabilityControl const & in_that);
11937 
11941  SelectabilityControl & SetWindows(Selectability::Value in_val);
11942 
11946  SelectabilityControl & SetWindows(bool in_val);
11947 
11951  SelectabilityControl & SetEdges(Selectability::Value in_val);
11952 
11956  SelectabilityControl & SetEdges(bool in_val);
11957 
11961  SelectabilityControl & SetFaces(Selectability::Value in_val);
11962 
11966  SelectabilityControl & SetFaces(bool in_val);
11967 
11971  SelectabilityControl & SetLights(Selectability::Value in_val);
11972 
11976  SelectabilityControl & SetLights(bool in_val);
11977 
11981  SelectabilityControl & SetLines(Selectability::Value in_val);
11982 
11986  SelectabilityControl & SetLines(bool in_val);
11987 
11991  SelectabilityControl & SetMarkers(Selectability::Value in_val);
11992 
11996  SelectabilityControl & SetMarkers(bool in_val);
11997 
12001  SelectabilityControl & SetVertices(Selectability::Value in_val);
12002 
12006  SelectabilityControl & SetVertices(bool in_val);
12007 
12011  SelectabilityControl & SetText(Selectability::Value in_val);
12012 
12016  SelectabilityControl & SetText(bool in_val);
12017 
12021  SelectabilityControl & SetGeometry(Selectability::Value in_val);
12022 
12026  SelectabilityControl & SetGeometry(bool in_val);
12027 
12031  SelectabilityControl & SetEverything(Selectability::Value in_val);
12032 
12036  SelectabilityControl & SetEverything(bool in_val);
12037 
12038 
12042  SelectabilityControl & UnsetWindows();
12043 
12047  SelectabilityControl & UnsetEdges();
12048 
12052  SelectabilityControl & UnsetFaces();
12053 
12057  SelectabilityControl & UnsetLights();
12058 
12062  SelectabilityControl & UnsetLines();
12063 
12067  SelectabilityControl & UnsetMarkers();
12068 
12072  SelectabilityControl & UnsetVertices();
12073 
12077  SelectabilityControl & UnsetText();
12078 
12082  SelectabilityControl & UnsetGeometry();
12083 
12087  SelectabilityControl & UnsetEverything();
12088 
12089 
12093  bool ShowWindows(Selectability::Value & out_val) const;
12094 
12098  bool ShowEdges(Selectability::Value & out_val) const;
12099 
12103  bool ShowFaces(Selectability::Value & out_val) const;
12104 
12108  bool ShowLights(Selectability::Value & out_val) const;
12109 
12113  bool ShowLines(Selectability::Value & out_val) const;
12114 
12118  bool ShowMarkers(Selectability::Value & out_val) const;
12119 
12123  bool ShowVertices(Selectability::Value & out_val) const;
12124 
12128  bool ShowText(Selectability::Value & out_val) const;
12129 
12130 private:
12133 };
12134 
12135 
12137 class HPS_API TransparencyKit : public Kit
12138 {
12139 public:
12140 
12142  TransparencyKit();
12143 
12146  TransparencyKit(TransparencyKit const & in_kit);
12147 
12151  TransparencyKit(TransparencyKit && in_that);
12152 
12156  TransparencyKit & operator=(TransparencyKit && in_that);
12157 
12159  virtual ~TransparencyKit();
12160 
12161  static const HPS::Type staticType = HPS::Type::TransparencyKit;
12162  HPS::Type ObjectType() const {return staticType;};
12163 
12167  static TransparencyKit GetDefault();
12168 
12171  void Set(TransparencyKit const & in_kit);
12172 
12175  void Show(TransparencyKit & out_kit) const;
12176 
12180  TransparencyKit & operator=(TransparencyKit const & in_kit);
12181 
12184  bool Empty() const;
12185 
12189  bool Equals(TransparencyKit const & in_kit) const;
12190 
12194  bool operator==(TransparencyKit const & in_kit) const;
12195 
12199  bool operator!=(TransparencyKit const & in_kit) const;
12200 
12201 
12205  TransparencyKit & SetMethod(Transparency::Method in_style);
12206 
12210  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
12211 
12217  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
12218 
12223  TransparencyKit & SetDepthPeelingPreference(Transparency::Preference in_preference);
12224 
12230  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
12231 
12236  TransparencyKit & SetDepthWriting(bool in_state);
12237 
12238 
12241  TransparencyKit & UnsetMethod();
12242 
12245  TransparencyKit & UnsetAlgorithm();
12246 
12249  TransparencyKit & UnsetDepthPeelingLayers();
12250 
12253  TransparencyKit & UnsetDepthPeelingMinimumArea();
12254 
12257  TransparencyKit & UnsetDepthWriting();
12258 
12261  TransparencyKit & UnsetDepthPeelingPreference();
12262 
12265  TransparencyKit & UnsetEverything();
12266 
12267 
12271  bool ShowMethod(Transparency::Method & out_style) const;
12272 
12276  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
12277 
12281  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
12282 
12287  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
12288 
12292  bool ShowDepthWriting(bool & out_state) const;
12293 
12297  bool ShowDepthPeelingPreference(Transparency::Preference & out_preference) const;
12298 };
12299 
12305 class HPS_API TransparencyControl : public Control
12306 {
12307 public:
12308 
12310  explicit TransparencyControl(SegmentKey & in_seg);
12311 
12313  TransparencyControl(TransparencyControl const & in_that);
12314 
12319 
12323  TransparencyControl & operator=(TransparencyControl && in_that);
12324 
12327 
12328  virtual HPS::Type Type() const { return ObjectType(); }
12329 
12330  static const HPS::Type staticType = HPS::Type::TransparencyControl;
12331  HPS::Type ObjectType() const {return staticType;};
12332 
12336  TransparencyControl & operator=(TransparencyControl const & in_that);
12337 
12341  TransparencyControl & SetMethod(Transparency::Method in_style);
12342 
12346  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
12347 
12353  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
12354 
12360  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
12361 
12366  TransparencyControl & SetDepthWriting(bool in_state);
12367 
12372  TransparencyControl & SetDepthPeelingPreference(Transparency::Preference in_preference);
12373 
12377  TransparencyControl & UnsetMethod();
12378 
12382  TransparencyControl & UnsetAlgorithm();
12383 
12387  TransparencyControl & UnsetDepthPeelingLayers();
12388 
12392  TransparencyControl & UnsetDepthPeelingMinimumArea();
12393 
12397  TransparencyControl & UnsetDepthWriting();
12398 
12402  TransparencyControl & UnsetDepthPeelingPreference();
12403 
12407  TransparencyControl & UnsetEverything();
12408 
12412  bool ShowMethod(Transparency::Method & out_style) const;
12413 
12417  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
12418 
12422  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
12423 
12428  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
12429 
12433  bool ShowDepthWriting(bool & out_state) const;
12434 
12438  bool ShowDepthPeelingPreference(Transparency::Preference & out_preference) const;
12439 
12440 private:
12443 };
12444 
12446 class HPS_API ColorInterpolationKit : public Kit
12447 {
12448 public:
12449 
12452 
12455 
12460 
12464  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
12465 
12467  virtual ~ColorInterpolationKit();
12468 
12469  static const HPS::Type staticType = HPS::Type::ColorInterpolationKit;
12470  HPS::Type ObjectType() const {return staticType;};
12471 
12472  static ColorInterpolationKit GetDefault();
12473 
12475  void Set(ColorInterpolationKit const & in_kit);
12476 
12478  void Show(ColorInterpolationKit & out_kit) const;
12479 
12481  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
12482 
12484  bool Empty() const;
12485 
12487  bool Equals(ColorInterpolationKit const & in_kit) const;
12488 
12490  bool operator==(ColorInterpolationKit const & in_kit) const;
12491 
12493  bool operator!=(ColorInterpolationKit const & in_kit) const;
12494 
12495 
12499  ColorInterpolationKit & SetFaceColor(bool in_state);
12500 
12504  ColorInterpolationKit & SetEdgeColor(bool in_state);
12505 
12509  ColorInterpolationKit & SetVertexColor(bool in_state);
12510 
12514  ColorInterpolationKit & SetFaceIndex(bool in_state);
12515 
12519  ColorInterpolationKit & SetEdgeIndex(bool in_state);
12520 
12524  ColorInterpolationKit & SetVertexIndex(bool in_state);
12525 
12526 
12529  ColorInterpolationKit & UnsetFaceColor();
12530 
12533  ColorInterpolationKit & UnsetEdgeColor();
12534 
12537  ColorInterpolationKit & UnsetVertexColor();
12538 
12541  ColorInterpolationKit & UnsetFaceIndex();
12542 
12545  ColorInterpolationKit & UnsetEdgeIndex();
12546 
12549  ColorInterpolationKit & UnsetVertexIndex();
12550 
12553  ColorInterpolationKit & UnsetEverything();
12554 
12555 
12559  bool ShowFaceColor(bool & out_state) const;
12560 
12564  bool ShowEdgeColor(bool & out_state) const;
12565 
12569  bool ShowVertexColor(bool & out_state) const;
12570 
12574  bool ShowFaceIndex(bool & out_state) const;
12575 
12579  bool ShowEdgeIndex(bool & out_state) const;
12580 
12584  bool ShowVertexIndex(bool & out_state) const;
12585 };
12586 
12587 
12591 class HPS_API ColorInterpolationControl : public Control
12592 {
12593 public:
12594 
12596  explicit ColorInterpolationControl(SegmentKey & in_seg);
12597 
12600 
12605 
12609  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
12610 
12613 
12614  virtual HPS::Type Type() const { return ObjectType(); }
12615 
12616  static const HPS::Type staticType = HPS::Type::ColorInterpolationControl;
12617  HPS::Type ObjectType() const {return staticType;};
12618 
12622  ColorInterpolationControl & operator=(ColorInterpolationControl const & in_that);
12623 
12627  ColorInterpolationControl & SetFaceColor(bool in_state);
12628 
12632  ColorInterpolationControl & SetEdgeColor(bool in_state);
12633 
12637  ColorInterpolationControl & SetVertexColor(bool in_state);
12638 
12642  ColorInterpolationControl & SetFaceIndex(bool in_state);
12643 
12647  ColorInterpolationControl & SetEdgeIndex(bool in_state);
12648 
12652  ColorInterpolationControl & SetVertexIndex(bool in_state);
12653 
12654 
12658  ColorInterpolationControl & UnsetFaceColor();
12659 
12663  ColorInterpolationControl & UnsetEdgeColor();
12664 
12668  ColorInterpolationControl & UnsetVertexColor();
12669 
12673  ColorInterpolationControl & UnsetFaceIndex();
12674 
12678  ColorInterpolationControl & UnsetEdgeIndex();
12679 
12683  ColorInterpolationControl & UnsetVertexIndex();
12684 
12688  ColorInterpolationControl & UnsetEverything();
12689 
12690 
12694  bool ShowFaceColor(bool & out_state) const;
12695 
12699  bool ShowEdgeColor(bool & out_state) const;
12700 
12704  bool ShowVertexColor(bool & out_state) const;
12705 
12709  bool ShowFaceIndex(bool & out_state) const;
12710 
12714  bool ShowEdgeIndex(bool & out_state) const;
12715 
12719  bool ShowVertexIndex(bool & out_state) const;
12720 
12721 private:
12724 };
12725 
12726 
12728 class HPS_API CullingKit : public Kit
12729 {
12730 public:
12731 
12733  CullingKit();
12734 
12737  CullingKit(CullingKit const & in_kit);
12738 
12742  CullingKit(CullingKit && in_that);
12743 
12747  CullingKit & operator=(CullingKit && in_that);
12748 
12750  virtual ~CullingKit();
12751 
12752  static const HPS::Type staticType = HPS::Type::CullingKit;
12753  HPS::Type ObjectType() const {return staticType;};
12754 
12758  static CullingKit GetDefault();
12759 
12762  void Set(CullingKit const & in_kit);
12763 
12766  void Show(CullingKit & out_kit) const;
12767 
12771  CullingKit & operator=(CullingKit const & in_kit);
12772 
12775  bool Empty() const;
12776 
12780  bool Equals(CullingKit const & in_kit) const;
12781 
12785  bool operator==(CullingKit const & in_kit) const;
12786 
12790  bool operator!=(CullingKit const & in_kit) const;
12791 
12796  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
12797 
12802  CullingKit & SetDeferralExtent(unsigned int in_pixels);
12803 
12808  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
12809 
12814  CullingKit & SetExtent(unsigned int in_pixels);
12815 
12819  CullingKit & SetBackFace(bool in_state);
12820 
12827  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
12828 
12835  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
12836 
12843  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
12844 
12850  CullingKit & SetVector(HPS::Vector const & in_vector);
12851 
12855  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
12856 
12860  CullingKit & SetFrustum(bool in_state);
12861 
12869  CullingKit & SetVolume(bool in_state, HPS::SimpleCuboid const & in_volume = HPS::SimpleCuboid());
12870 
12877  CullingKit & SetVolume(HPS::SimpleCuboid const & in_volume);
12878 
12886  CullingKit & SetDistance(bool in_state, float in_max_distance);
12887 
12895  CullingKit & SetDistance(float in_max_distance);
12896 
12899  CullingKit & UnsetDeferralExtent();
12900 
12903  CullingKit & UnsetExtent();
12904 
12907  CullingKit & UnsetBackFace();
12908 
12911  CullingKit & UnsetVector();
12912 
12915  CullingKit & UnsetVectorTolerance();
12916 
12919  CullingKit & UnsetFrustum();
12920 
12923  CullingKit & UnsetVolume();
12924 
12927  CullingKit & UnsetDistance();
12928 
12931  CullingKit & UnsetEverything();
12932 
12937  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12938 
12943  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12944 
12948  bool ShowBackFace(bool & out_state) const;
12949 
12955  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
12956 
12960  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
12961 
12965  bool ShowFrustum(bool & out_state) const;
12966 
12972  bool ShowVolume(bool & out_state, HPS::SimpleCuboid & out_volume) const;
12973 
12979  bool ShowDistance(bool & out_state, float & out_max_distance) const;
12980 };
12981 
12985 class HPS_API CullingControl : public Control
12986 {
12987 public:
12988 
12990  explicit CullingControl(SegmentKey & in_seg);
12991 
12993  CullingControl(CullingControl const & in_that);
12994 
12996  ~CullingControl();
12997 
13001  CullingControl(CullingControl && in_that);
13002 
13006  CullingControl & operator=(CullingControl && in_that);
13007 
13008  virtual HPS::Type Type() const { return ObjectType(); }
13009 
13010  static const HPS::Type staticType = HPS::Type::CullingControl;
13011  HPS::Type ObjectType() const {return staticType;};
13012 
13016  CullingControl & operator=(CullingControl const & in_that);
13017 
13024  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
13025 
13032  CullingControl & SetDeferralExtent(unsigned int in_pixels);
13033 
13038  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
13039 
13044  CullingControl & SetExtent(unsigned int in_pixels);
13045 
13050  CullingControl & SetBackFace(bool in_state);
13051 
13058  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
13059 
13066  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
13067 
13074  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
13075 
13081  CullingControl & SetVector(HPS::Vector const & in_vector);
13082 
13086  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
13087 
13091  CullingControl & SetFrustum(bool in_state);
13092 
13100  CullingControl & SetVolume(bool in_state, HPS::SimpleCuboid const & in_volume = HPS::SimpleCuboid());
13101 
13108  CullingControl & SetVolume(HPS::SimpleCuboid const & in_volume);
13109 
13117  CullingControl & SetDistance(bool in_state, float in_max_distance);
13118 
13126  CullingControl & SetDistance(float in_max_distance);
13127 
13131  CullingControl & UnsetDeferralExtent();
13132 
13136  CullingControl & UnsetExtent();
13137 
13141  CullingControl & UnsetBackFace();
13142 
13146  CullingControl & UnsetVector();
13147 
13151  CullingControl & UnsetVectorTolerance();
13152 
13156  CullingControl & UnsetFrustum();
13157 
13161  CullingControl & UnsetVolume();
13162 
13166  CullingControl & UnsetDistance();
13167 
13171  CullingControl & UnsetEverything();
13172 
13177  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
13178 
13183  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
13184 
13188  bool ShowBackFace(bool & out_state) const;
13189 
13195  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
13196 
13200  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
13201 
13205  bool ShowFrustum(bool & out_state) const;
13206 
13212  bool ShowVolume(bool & out_state, HPS::SimpleCuboid & out_volume) const;
13213 
13219  bool ShowDistance(bool & out_state, float & out_max_distance) const;
13220 
13221 private:
13223  CullingControl();
13224 };
13225 
13226 
13227 
13228 
13230 class HPS_API MarkerAttributeKit : public Kit
13231 {
13232 public:
13233 
13236 
13239  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
13240 
13245 
13249  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
13250 
13252  virtual ~MarkerAttributeKit();
13253 
13254  static const HPS::Type staticType = HPS::Type::MarkerAttributeKit;
13255  HPS::Type ObjectType() const {return staticType;};
13256 
13260  static MarkerAttributeKit GetDefault();
13261 
13264  void Set(MarkerAttributeKit const & in_kit);
13265 
13268  void Show(MarkerAttributeKit & out_kit) const;
13269 
13273  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
13274 
13277  bool Empty() const;
13278 
13282  bool Equals(MarkerAttributeKit const & in_kit) const;
13283 
13287  bool operator==(MarkerAttributeKit const & in_kit) const;
13288 
13292  bool operator!=(MarkerAttributeKit const & in_kit) const;
13293 
13294 
13298  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
13299 
13304  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
13305 
13309  MarkerAttributeKit & SetDrawingPreference(Marker::DrawingPreference in_preference);
13310 
13314  MarkerAttributeKit & SetGlyphRotation(float in_rotation);
13315 
13318  MarkerAttributeKit & UnsetSymbol();
13319 
13322  MarkerAttributeKit & UnsetSize();
13323 
13326  MarkerAttributeKit & UnsetDrawingPreference();
13327 
13330  MarkerAttributeKit & UnsetGlyphRotation();
13331 
13334  MarkerAttributeKit & UnsetEverything();
13335 
13339  bool ShowSymbol(UTF8 & out_glyph_name) const;
13340 
13345  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
13346 
13350  bool ShowDrawingPreference(Marker::DrawingPreference & out_preference) const;
13351 
13355  bool ShowGlyphRotation(float & out_rotation) const;
13356 };
13357 
13363 class HPS_API MarkerAttributeControl : public Control
13364 {
13365 public:
13366 
13368  explicit MarkerAttributeControl(SegmentKey & in_seg);
13369 
13372 
13377 
13381  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
13382 
13385 
13386  virtual HPS::Type Type() const { return ObjectType(); }
13387 
13388  static const HPS::Type staticType = HPS::Type::MarkerAttributeControl;
13389  HPS::Type ObjectType() const {return staticType;};
13390 
13394  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
13395 
13399  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
13400 
13405  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
13406 
13410  MarkerAttributeControl & SetDrawingPreference(Marker::DrawingPreference in_preference);
13411 
13415  MarkerAttributeControl & SetGlyphRotation(float in_rotation);
13416 
13420  MarkerAttributeControl & UnsetSymbol();
13421 
13425  MarkerAttributeControl & UnsetSize();
13426 
13429  MarkerAttributeControl & UnsetDrawingPreference();
13430 
13433  MarkerAttributeControl & UnsetGlyphRotation();
13434 
13438  MarkerAttributeControl & UnsetEverything();
13439 
13440 
13444  bool ShowSymbol(UTF8 & out_glyph_name) const;
13445 
13450  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
13451 
13455  bool ShowDrawingPreference(Marker::DrawingPreference & out_preference) const;
13456 
13460  bool ShowGlyphRotation(float & out_rotation) const;
13461 
13462 private:
13465 };
13466 
13467 
13469 class HPS_API SphereAttributeKit : public Kit
13470 {
13471 public:
13472 
13475 
13478  SphereAttributeKit(SphereAttributeKit const & in_kit);
13479 
13484 
13488  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
13489 
13491  virtual ~SphereAttributeKit();
13492 
13493  static const HPS::Type staticType = HPS::Type::SphereAttributeKit;
13494  HPS::Type ObjectType() const {return staticType;};
13495 
13499  static SphereAttributeKit GetDefault();
13500 
13503  void Set(SphereAttributeKit const & in_kit);
13504 
13507  void Show(SphereAttributeKit & out_kit) const;
13508 
13512  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
13513 
13516  bool Empty() const;
13517 
13521  bool Equals(SphereAttributeKit const & in_kit) const;
13522 
13526  bool operator==(SphereAttributeKit const & in_kit) const;
13527 
13531  bool operator!=(SphereAttributeKit const & in_kit) const;
13532 
13533 
13537  SphereAttributeKit & SetTessellation(size_t in_facets);
13538 
13539 
13542  SphereAttributeKit & UnsetTessellation();
13543 
13546  SphereAttributeKit & UnsetEverything();
13547 
13548 
13552  bool ShowTessellation(size_t & out_facets) const;
13553 };
13554 
13555 
13558 class HPS_API SphereAttributeControl : public Control
13559 {
13560 public:
13561 
13563  explicit SphereAttributeControl(SegmentKey const & in_seg);
13564 
13567 
13572 
13576  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
13577 
13580 
13581  virtual HPS::Type Type() const { return ObjectType(); }
13582 
13583  static const HPS::Type staticType = HPS::Type::SphereAttributeControl;
13584  HPS::Type ObjectType() const {return staticType;};
13585 
13589  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
13590 
13595  SphereAttributeControl & SetTessellation(size_t in_facets);
13596 
13597 
13601  SphereAttributeControl & UnsetTessellation();
13602 
13606  SphereAttributeControl & UnsetEverything();
13607 
13608 
13612  bool ShowTessellation(size_t & out_facets) const;
13613 
13614 private:
13617 };
13618 
13619 
13621 class HPS_API LightingAttributeKit : public Kit
13622 {
13623 public:
13624 
13627 
13631 
13636 
13640  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
13641 
13643  virtual ~LightingAttributeKit();
13644 
13645  static const HPS::Type staticType = HPS::Type::LightingAttributeKit;
13646  HPS::Type ObjectType() const {return staticType;};
13647 
13651  static LightingAttributeKit GetDefault();
13652 
13655  void Set(LightingAttributeKit const & in_kit);
13656 
13659  void Show(LightingAttributeKit & out_kit) const;
13660 
13664  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
13665 
13668  bool Empty() const;
13669 
13673  bool Equals(LightingAttributeKit const & in_kit) const;
13674 
13678  bool operator==(LightingAttributeKit const & in_kit) const;
13679 
13683  bool operator!=(LightingAttributeKit const & in_kit) const;
13684 
13685 
13689  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
13690 
13691 
13694  LightingAttributeKit & UnsetInterpolationAlgorithm();
13695 
13698  LightingAttributeKit & UnsetEverything();
13699 
13700 
13704  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
13705 };
13706 
13707 
13708 
13714 class HPS_API LightingAttributeControl : public Control
13715 {
13716 public:
13717 
13719  explicit LightingAttributeControl(SegmentKey & in_seg);
13720 
13723 
13728 
13732  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
13733 
13736 
13737  virtual HPS::Type Type() const { return ObjectType(); }
13738 
13739  static const HPS::Type staticType = HPS::Type::LightingAttributeControl;
13740  HPS::Type ObjectType() const {return staticType;};
13741 
13745  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
13746 
13750  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
13751 
13752 
13756  LightingAttributeControl & UnsetInterpolationAlgorithm();
13757 
13761  LightingAttributeControl & UnsetEverything();
13762 
13763 
13767  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
13768 
13769 private:
13772 };
13773 
13774 
13775 
13777 class HPS_API CylinderAttributeKit : public Kit
13778 {
13779 public:
13780 
13783 
13787 
13792 
13796  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
13797 
13799  virtual ~CylinderAttributeKit();
13800 
13801  static const HPS::Type staticType = HPS::Type::CylinderAttributeKit;
13802  HPS::Type ObjectType() const {return staticType;};
13803 
13807  static CylinderAttributeKit GetDefault();
13808 
13811  void Set(CylinderAttributeKit const & in_kit);
13812 
13815  void Show(CylinderAttributeKit & out_kit) const;
13816 
13820  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
13821 
13824  bool Empty() const;
13825 
13829  bool Equals(CylinderAttributeKit const & in_kit) const;
13830 
13834  bool operator==(CylinderAttributeKit const & in_kit) const;
13835 
13839  bool operator!=(CylinderAttributeKit const & in_kit) const;
13840 
13841 
13845  CylinderAttributeKit & SetTessellation(size_t in_facets);
13846 
13851  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
13852 
13853 
13856  CylinderAttributeKit & UnsetTessellation();
13857 
13860  CylinderAttributeKit & UnsetOrientation();
13861 
13864  CylinderAttributeKit & UnsetEverything();
13865 
13866 
13870  bool ShowTessellation(size_t & out_facets) const;
13871 
13875  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
13876 };
13877 
13878 
13879 
13883 class HPS_API CylinderAttributeControl : public Control
13884 {
13885 public:
13886 
13888  explicit CylinderAttributeControl(SegmentKey & in_seg);
13889 
13892 
13897 
13901  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
13902 
13905 
13906  virtual HPS::Type Type() const { return ObjectType(); }
13907 
13908  static const HPS::Type staticType = HPS::Type::CylinderAttributeControl;
13909  HPS::Type ObjectType() const {return staticType;};
13910 
13914  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
13915 
13919  CylinderAttributeControl & SetTessellation(size_t in_facets);
13920 
13925  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
13926 
13927 
13931  CylinderAttributeControl & UnsetTessellation();
13932 
13936  CylinderAttributeControl & UnsetOrientation();
13937 
13941  CylinderAttributeControl & UnsetEverything();
13942 
13943 
13947  bool ShowTessellation(size_t & out_facets) const;
13948 
13952  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
13953 
13954 private:
13957 };
13958 
13959 
13960 
13962 class HPS_API CuttingSectionAttributeKit : public Kit
13963 {
13964 public:
13965 
13968 
13972 
13977 
13982 
13984  virtual ~CuttingSectionAttributeKit();
13985 
13986  static const HPS::Type staticType = HPS::Type::CuttingSectionAttributeKit;
13987  HPS::Type ObjectType() const {return staticType;};
13988 
13992  static CuttingSectionAttributeKit GetDefault();
13993 
13996  void Set(CuttingSectionAttributeKit const & in_kit);
13997 
14000  void Show(CuttingSectionAttributeKit & out_kit) const;
14001 
14005  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
14006 
14009  bool Empty() const;
14010 
14014  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
14015 
14019  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
14020 
14024  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
14025 
14030  CuttingSectionAttributeKit & SetEdgeWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
14031 
14036  CuttingSectionAttributeKit & SetTolerance(float in_tolerance, CuttingSection::ToleranceUnits in_units);
14037 
14041  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
14042 
14046  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
14047 
14051  CuttingSectionAttributeKit & SetCappingUsage(CuttingSection::CappingUsage in_usage);
14052 
14056  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
14057 
14060  CuttingSectionAttributeKit & UnsetEdgeWeight();
14061 
14064  CuttingSectionAttributeKit & UnsetTolerance();
14065 
14068  CuttingSectionAttributeKit & UnsetCuttingLevel();
14069 
14072  CuttingSectionAttributeKit & UnsetCappingLevel();
14073 
14076  CuttingSectionAttributeKit & UnsetCappingUsage();
14077 
14080  CuttingSectionAttributeKit & UnsetMaterialPreference();
14081 
14084  CuttingSectionAttributeKit & UnsetEverything();
14085 
14086 
14090  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
14091 
14095  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
14096 
14100  bool ShowCappingUsage(CuttingSection::CappingUsage & out_usage) const;
14101 
14105  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
14106 
14111  bool ShowEdgeWeight(float & out_weight, Line::SizeUnits & out_units) const;
14112 
14117  bool ShowTolerance(float & out_tolerance, CuttingSection::ToleranceUnits & out_units) const;
14118 };
14119 
14120 
14121 
14126 {
14127 public:
14128 
14130  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
14131 
14134 
14139 
14144 
14147 
14148  virtual HPS::Type Type() const { return ObjectType(); }
14149 
14150  static const HPS::Type staticType = HPS::Type::CuttingSectionAttributeControl;
14151  HPS::Type ObjectType() const {return staticType;};
14152 
14157 
14162  CuttingSectionAttributeControl & SetEdgeWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
14163 
14168  CuttingSectionAttributeControl & SetTolerance(float in_tolerance, CuttingSection::ToleranceUnits in_units);
14169 
14174 
14179 
14184 
14188  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
14189 
14193  CuttingSectionAttributeControl & UnsetEdgeWeight();
14194 
14198  CuttingSectionAttributeControl & UnsetTolerance();
14199 
14200 
14204  CuttingSectionAttributeControl & UnsetCuttingLevel();
14205 
14209  CuttingSectionAttributeControl & UnsetCappingLevel();
14210 
14214  CuttingSectionAttributeControl & UnsetCappingUsage();
14215 
14219  CuttingSectionAttributeControl & UnsetMaterialPreference();
14220 
14224  CuttingSectionAttributeControl & UnsetEverything();
14225 
14226 
14230  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
14231 
14235  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
14236 
14240  bool ShowCappingUsage(CuttingSection::CappingUsage & out_usage) const;
14241 
14245  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
14246 
14251  bool ShowEdgeWeight(float & out_weight, Line::SizeUnits & out_units) const;
14252 
14257  bool ShowTolerance(float & out_tolerance, CuttingSection::ToleranceUnits & out_units) const;
14258 
14259 private:
14262 };
14263 
14264 
14265 
14267 class HPS_API TextAttributeKit : public Kit
14268 {
14269 public:
14270 
14272  TextAttributeKit();
14273 
14276  TextAttributeKit(TextAttributeKit const & in_kit);
14277 
14281  TextAttributeKit(TextAttributeKit && in_that);
14282 
14286  TextAttributeKit & operator=(TextAttributeKit && in_that);
14287 
14289  virtual ~TextAttributeKit();
14290 
14291  static const HPS::Type staticType = HPS::Type::TextAttributeKit;
14292  HPS::Type ObjectType() const {return staticType;};
14293 
14297  static TextAttributeKit GetDefault();
14298 
14301  void Set(TextAttributeKit const & in_kit);
14302 
14305  void Show(TextAttributeKit & out_kit) const;
14306 
14310  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
14311 
14314  bool Empty() const;
14315 
14319  bool Equals(TextAttributeKit const & in_kit) const;
14320 
14324  bool operator==(TextAttributeKit const & in_kit) const;
14325 
14329  bool operator!=(TextAttributeKit const & in_kit) const;
14330 
14331 
14338 
14343  TextAttributeKit & SetBold(bool in_state);
14344 
14349  TextAttributeKit & SetItalic(bool in_state);
14350 
14354  TextAttributeKit & SetOverline(bool in_state);
14355 
14359  TextAttributeKit & SetStrikethrough(bool in_state);
14360 
14364  TextAttributeKit & SetUnderline(bool in_state);
14365 
14371  TextAttributeKit & SetSlant(float in_angle);
14372 
14377  TextAttributeKit & SetLineSpacing(float in_multiplier);
14378 
14384  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
14385 
14391  TextAttributeKit & SetRotation(float in_angle);
14392 
14398  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
14399 
14405  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
14406 
14413  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
14414 
14421 
14431  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
14432 
14442  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
14443 
14448  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
14449 
14456  TextAttributeKit & SetFont(char const * in_name);
14457 
14461  TextAttributeKit & SetTransform(Text::Transform in_trans);
14462 
14466  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
14467 
14472  TextAttributeKit & SetPreference(Text::Preference in_pref);
14473 
14481  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
14482 
14487  TextAttributeKit & SetPath(Vector const & in_path);
14488 
14496  TextAttributeKit & SetSpacing(float in_multiplier);
14497 
14502  TextAttributeKit & SetBackground(bool in_state, char const * in_name);
14503 
14508  TextAttributeKit & SetBackground(char const * in_name);
14509 
14513  TextAttributeKit & SetBackground(bool in_state);
14514 
14519  TextAttributeKit & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
14520 
14526  TextAttributeKit & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
14527 
14534  TextAttributeKit & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
14535 
14540  TextAttributeKit & SetBackgroundStyle(char const * in_name);
14541 
14542 
14545  TextAttributeKit & UnsetAlignment();
14546 
14549  TextAttributeKit & UnsetBold();
14550 
14553  TextAttributeKit & UnsetItalic();
14554 
14557  TextAttributeKit & UnsetOverline();
14558 
14561  TextAttributeKit & UnsetStrikethrough();
14562 
14565  TextAttributeKit & UnsetUnderline();
14566 
14569  TextAttributeKit & UnsetSlant();
14570 
14573  TextAttributeKit & UnsetLineSpacing();
14574 
14577  TextAttributeKit & UnsetRotation();
14578 
14581  TextAttributeKit & UnsetExtraSpace();
14582 
14585  TextAttributeKit & UnsetGreeking();
14586 
14589  TextAttributeKit & UnsetSizeTolerance();
14590 
14593  TextAttributeKit & UnsetSize();
14594 
14597  TextAttributeKit & UnsetFont();
14598 
14601  TextAttributeKit & UnsetTransform();
14602 
14605  TextAttributeKit & UnsetRenderer();
14606 
14609  TextAttributeKit & UnsetPreference();
14610 
14613  TextAttributeKit & UnsetPath();
14614 
14617  TextAttributeKit & UnsetSpacing();
14618 
14621  TextAttributeKit & UnsetBackground();
14622 
14625  TextAttributeKit & UnsetBackgroundMargins();
14626 
14629  TextAttributeKit & UnsetBackgroundStyle();
14630 
14633  TextAttributeKit & UnsetEverything();
14634 
14635 
14641  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
14642 
14646  bool ShowBold(bool & out_state) const;
14647 
14651  bool ShowItalic(bool & out_state) const;
14652 
14656  bool ShowOverline(bool & out_state) const;
14657 
14661  bool ShowStrikethrough(bool & out_state) const;
14662 
14666  bool ShowUnderline(bool & out_state) const;
14667 
14671  bool ShowSlant(float & out_angle) const;
14672 
14676  bool ShowLineSpacing(float & out_multiplier) const;
14677 
14682  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
14683 
14689  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
14690 
14697  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
14698 
14704  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
14705 
14710  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
14711 
14715  bool ShowFont(UTF8 & out_name) const;
14716 
14720  bool ShowTransform(Text::Transform & out_trans) const;
14721 
14725  bool ShowRenderer(Text::Renderer & out_rend) const;
14726 
14733  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
14734 
14738  bool ShowPath(Vector & out_path) const;
14739 
14743  bool ShowSpacing(float & out_multiplier) const;
14744 
14749  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
14750 
14755  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
14756 
14760  bool ShowBackgroundStyle(UTF8 & out_name) const;
14761 };
14762 
14768 class HPS_API TextAttributeControl : public Control
14769 {
14770 public:
14771 
14773  explicit TextAttributeControl(SegmentKey & in_seg);
14774 
14776  TextAttributeControl(TextAttributeControl const & in_that);
14777 
14782 
14786  TextAttributeControl & operator=(TextAttributeControl && in_that);
14787 
14790 
14791  virtual HPS::Type Type() const { return ObjectType(); }
14792 
14793  static const HPS::Type staticType = HPS::Type::TextAttributeControl;
14794  HPS::Type ObjectType() const {return staticType;};
14795 
14799  TextAttributeControl & operator=(TextAttributeControl const & in_that);
14800 
14807 
14812  TextAttributeControl & SetBold(bool in_state);
14813 
14818  TextAttributeControl & SetItalic(bool in_state);
14819 
14823  TextAttributeControl & SetOverline(bool in_state);
14824 
14828  TextAttributeControl & SetStrikethrough(bool in_state);
14829 
14833  TextAttributeControl & SetUnderline(bool in_state);
14834 
14840  TextAttributeControl & SetSlant(float in_angle);
14841 
14846  TextAttributeControl & SetLineSpacing(float in_multiplier);
14847 
14852  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
14853 
14858  TextAttributeControl & SetRotation(float in_angle);
14859 
14865  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
14866 
14872  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
14873 
14880  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
14881 
14888 
14898  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
14899 
14909  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
14910 
14915  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
14916 
14923  TextAttributeControl & SetFont(char const * in_name);
14924 
14928  TextAttributeControl & SetTransform(Text::Transform in_trans);
14929 
14933  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
14934 
14939  TextAttributeControl & SetPreference(Text::Preference in_pref);
14940 
14948  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
14949 
14954  TextAttributeControl & SetPath(Vector const & in_path);
14955 
14963  TextAttributeControl & SetSpacing(float in_multiplier);
14964 
14969  TextAttributeControl & SetBackground(bool in_state, char const * in_name);
14970 
14975  TextAttributeControl & SetBackground(char const * in_name);
14976 
14980  TextAttributeControl & SetBackground(bool in_state);
14981 
14986  TextAttributeControl & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
14987 
14993  TextAttributeControl & SetBackgroundMargins(FloatArray const & in_size, TextMarginUnitsArray const & in_units);
14994 
15001  TextAttributeControl & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
15002 
15007  TextAttributeControl & SetBackgroundStyle(char const * in_name);
15008 
15009 
15013  TextAttributeControl & UnsetAlignment();
15014 
15018  TextAttributeControl & UnsetBold();
15019 
15023  TextAttributeControl & UnsetItalic();
15024 
15028  TextAttributeControl & UnsetOverline();
15029 
15033  TextAttributeControl & UnsetStrikethrough();
15034 
15038  TextAttributeControl & UnsetUnderline();
15039 
15043  TextAttributeControl & UnsetSlant();
15044 
15048  TextAttributeControl & UnsetLineSpacing();
15049 
15053  TextAttributeControl & UnsetRotation();
15054 
15058  TextAttributeControl & UnsetExtraSpace();
15059 
15063  TextAttributeControl & UnsetGreeking();
15064 
15068  TextAttributeControl & UnsetSizeTolerance();
15069 
15073  TextAttributeControl & UnsetSize();
15074 
15078  TextAttributeControl & UnsetFont();
15079 
15083  TextAttributeControl & UnsetTransform();
15084 
15088  TextAttributeControl & UnsetRenderer();
15089 
15093  TextAttributeControl & UnsetPreference();
15094 
15098  TextAttributeControl & UnsetPath();
15099 
15103  TextAttributeControl & UnsetSpacing();
15104 
15108  TextAttributeControl & UnsetBackground();
15109 
15113  TextAttributeControl & UnsetBackgroundMargins();
15114 
15118  TextAttributeControl & UnsetBackgroundStyle();
15119 
15123  TextAttributeControl & UnsetEverything();
15124 
15125 
15131  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
15132 
15136  bool ShowBold(bool & out_state) const;
15137 
15141  bool ShowItalic(bool & out_state) const;
15142 
15146  bool ShowOverline(bool & out_state) const;
15147 
15151  bool ShowStrikethrough(bool & out_state) const;
15152 
15156  bool ShowUnderline(bool & out_state) const;
15157 
15161  bool ShowSlant(float & out_angle) const;
15162 
15166  bool ShowLineSpacing(float & out_multiplier) const;
15167 
15172  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
15173 
15179  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
15180 
15187  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
15188 
15194  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
15195 
15200  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
15201 
15205  bool ShowFont(UTF8 & out_name) const;
15206 
15210  bool ShowTransform(Text::Transform & out_trans) const;
15211 
15215  bool ShowRenderer(Text::Renderer & out_rend) const;
15216 
15223  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
15224 
15228  bool ShowPath(Vector & out_path) const;
15229 
15233  bool ShowSpacing(float & out_multiplier) const;
15234 
15239  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
15240 
15245  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
15246 
15250  bool ShowBackgroundStyle(UTF8 & out_name) const;
15251 
15252 private:
15255 };
15256 
15257 
15258 
15259 
15260 
15262 class HPS_API LineAttributeKit : public Kit
15263 {
15264 public:
15265 
15267  LineAttributeKit();
15268 
15271  LineAttributeKit(LineAttributeKit const & in_kit);
15272 
15276  LineAttributeKit(LineAttributeKit && in_that);
15277 
15281  LineAttributeKit & operator=(LineAttributeKit && in_that);
15282 
15284  virtual ~LineAttributeKit();
15285 
15286  static const HPS::Type staticType = HPS::Type::LineAttributeKit;
15287  HPS::Type ObjectType() const {return staticType;};
15288 
15292  static LineAttributeKit GetDefault();
15293 
15296  void Set(LineAttributeKit const & in_kit);
15297 
15300  void Show(LineAttributeKit & out_kit) const;
15301 
15305  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
15306 
15309  bool Empty() const;
15310 
15314  bool Equals(LineAttributeKit const & in_kit) const;
15315 
15319  bool operator==(LineAttributeKit const & in_kit) const;
15320 
15324  bool operator!=(LineAttributeKit const & in_kit) const;
15325 
15326 
15331  LineAttributeKit & SetPattern(char const * in_name);
15332 
15338  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
15339 
15344  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
15345 
15346 
15349  LineAttributeKit & UnsetPattern();
15350 
15353  LineAttributeKit & UnsetWeight();
15354 
15357  LineAttributeKit & UnsetEverything();
15358 
15359 
15364  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
15365 
15370  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
15371 };
15372 
15378 class HPS_API LineAttributeControl : public Control
15379 {
15380 public:
15381 
15383  explicit LineAttributeControl(SegmentKey & in_seg);
15384 
15386  LineAttributeControl(LineAttributeControl const & in_that);
15387 
15392 
15396  LineAttributeControl & operator=(LineAttributeControl && in_that);
15397 
15400 
15401  virtual HPS::Type Type() const { return ObjectType(); }
15402 
15403  static const HPS::Type staticType = HPS::Type::LineAttributeControl;
15404  HPS::Type ObjectType() const {return staticType;};
15405 
15409  LineAttributeControl & operator=(LineAttributeControl const & in_that);
15410 
15415  LineAttributeControl & SetPattern(char const * in_pattern);
15416 
15422  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
15423 
15428  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
15429 
15430 
15434  LineAttributeControl & UnsetPattern();
15435 
15439  LineAttributeControl & UnsetWeight();
15440 
15444  LineAttributeControl & UnsetEverything();
15445 
15446 
15451  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
15452 
15457  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
15458 
15459 private:
15462 };
15463 
15464 
15465 
15467 class HPS_API EdgeAttributeKit : public Kit
15468 {
15469 public:
15470 
15472  EdgeAttributeKit();
15473 
15476  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
15477 
15481  EdgeAttributeKit(EdgeAttributeKit && in_that);
15482 
15486  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
15487 
15489  virtual ~EdgeAttributeKit();
15490 
15491  static const HPS::Type staticType = HPS::Type::EdgeAttributeKit;
15492  HPS::Type ObjectType() const {return staticType;};
15493 
15497  static EdgeAttributeKit GetDefault();
15498 
15501  void Set(EdgeAttributeKit const & in_kit);
15502 
15505  void Show(EdgeAttributeKit & out_kit) const;
15506 
15510  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
15511 
15514  bool Empty() const;
15515 
15519  bool Equals(EdgeAttributeKit const & in_kit) const;
15520 
15524  bool operator==(EdgeAttributeKit const & in_kit) const;
15525 
15529  bool operator!=(EdgeAttributeKit const & in_kit) const;
15530 
15531 
15536  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
15537 
15542  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
15543 
15547  EdgeAttributeKit & SetHardAngle(float in_angle);
15548 
15549 
15552  EdgeAttributeKit & UnsetPattern();
15553 
15556  EdgeAttributeKit & UnsetWeight();
15557 
15560  EdgeAttributeKit & UnsetHardAngle();
15561 
15564  EdgeAttributeKit & UnsetEverything();
15565 
15566 
15570  bool ShowPattern(UTF8 & out_pattern_name) const;
15571 
15576  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
15577 
15581  bool ShowHardAngle(float & out_angle) const;
15582 
15583 };
15584 
15590 class HPS_API EdgeAttributeControl : public Control
15591 {
15592 public:
15593 
15595  explicit EdgeAttributeControl(SegmentKey & in_seg);
15596 
15598  EdgeAttributeControl(EdgeAttributeControl const & in_that);
15599 
15604 
15608  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
15609 
15612 
15613  virtual HPS::Type Type() const { return ObjectType(); }
15614 
15615  static const HPS::Type staticType = HPS::Type::EdgeAttributeControl;
15616  HPS::Type ObjectType() const {return staticType;};
15617 
15621  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
15622 
15627  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
15628 
15633  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
15634 
15638  EdgeAttributeControl & SetHardAngle(float in_angle);
15639 
15640 
15644  EdgeAttributeControl & UnsetPattern();
15645 
15649  EdgeAttributeControl & UnsetWeight();
15650 
15654  EdgeAttributeControl & UnsetHardAngle();
15655 
15659  EdgeAttributeControl & UnsetEverything();
15660 
15661 
15665  bool ShowPattern(UTF8 & out_pattern_name) const;
15666 
15671  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
15672 
15676  bool ShowHardAngle(float & out_angle) const;
15677 
15678 private:
15681 };
15682 
15683 
15685 class HPS_API CurveAttributeKit : public Kit
15686 {
15687 public:
15688 
15691 
15694  CurveAttributeKit(CurveAttributeKit const & in_kit);
15695 
15700 
15704  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
15705 
15707  virtual ~CurveAttributeKit();
15708 
15709  static const HPS::Type staticType = HPS::Type::CurveAttributeKit;
15710  HPS::Type ObjectType() const {return staticType;};
15711 
15715  static CurveAttributeKit GetDefault();
15716 
15719  void Set(CurveAttributeKit const & in_kit);
15720 
15723  void Show(CurveAttributeKit & out_kit) const;
15724 
15728  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
15729 
15732  bool Empty() const;
15733 
15737  bool Equals(CurveAttributeKit const & in_kit) const;
15738 
15742  bool operator==(CurveAttributeKit const & in_kit) const;
15743 
15747  bool operator!=(CurveAttributeKit const & in_kit) const;
15748 
15749  //Set
15750  CurveAttributeKit & SetBudget(size_t in_budget);
15751 
15758  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
15759 
15766  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
15767 
15768 
15775  CurveAttributeKit & SetViewDependent(bool in_state);
15776 
15780  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
15781 
15786  CurveAttributeKit & SetMaximumAngle(float in_degrees);
15787 
15792  CurveAttributeKit & SetMaximumLength(float in_length);
15793 
15794 
15797  CurveAttributeKit & UnsetBudget();
15798 
15801  CurveAttributeKit & UnsetContinuedBudget();
15802 
15805  CurveAttributeKit & UnsetViewDependent();
15806 
15809  CurveAttributeKit & UnsetMaximumDeviation();
15810 
15813  CurveAttributeKit & UnsetMaximumAngle();
15814 
15817  CurveAttributeKit & UnsetMaximumLength();
15818 
15821  CurveAttributeKit & UnsetEverything();
15822 
15823 
15827  bool ShowBudget(size_t & out_budget) const;
15828 
15833  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
15834 
15838  bool ShowViewDependent(bool & out_state) const;
15839 
15844  bool ShowMaximumDeviation(float & out_deviation) const;
15845 
15850  bool ShowMaximumAngle(float & out_degrees) const;
15851 
15856  bool ShowMaximumLength(float & out_length) const;
15857 };
15858 
15859 
15863 class HPS_API CurveAttributeControl : public Control
15864 {
15865 public:
15866 
15868  explicit CurveAttributeControl(SegmentKey & in_seg);
15869 
15872 
15877 
15881  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
15882 
15885 
15886  virtual HPS::Type Type() const { return ObjectType(); }
15887 
15888  static const HPS::Type staticType = HPS::Type::CurveAttributeControl;
15889  HPS::Type ObjectType() const {return staticType;};
15890 
15894  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
15895 
15899  CurveAttributeControl & SetBudget(size_t in_budget);
15900 
15907  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
15908 
15915  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
15916 
15923  CurveAttributeControl & SetViewDependent(bool in_state);
15924 
15928  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
15929 
15934  CurveAttributeControl & SetMaximumAngle(float in_degrees);
15935 
15940  CurveAttributeControl & SetMaximumLength(float in_length);
15941 
15942 
15946  CurveAttributeControl & UnsetBudget();
15947 
15951  CurveAttributeControl & UnsetContinuedBudget();
15952 
15956  CurveAttributeControl & UnsetViewDependent();
15957 
15961  CurveAttributeControl & UnsetMaximumDeviation();
15962 
15966  CurveAttributeControl & UnsetMaximumAngle();
15967 
15971  CurveAttributeControl & UnsetMaximumLength();
15972 
15976  CurveAttributeControl & UnsetEverything();
15977 
15978 
15982  bool ShowBudget(size_t & out_budget) const;
15983 
15988  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
15989 
15993  bool ShowViewDependent(bool & out_state) const;
15994 
15999  bool ShowMaximumDeviation(float & out_deviation) const;
16000 
16005  bool ShowMaximumAngle(float & out_degrees) const;
16006 
16011  bool ShowMaximumLength(float & out_length) const;
16012 
16013 private:
16016 };
16017 
16019 class HPS_API MatrixKit
16020 {
16021 public:
16022  float data[16];
16023 
16025  MatrixKit();
16026 
16029  MatrixKit(MatrixKit const & in_other);
16030 
16034  MatrixKit(FloatArray const & in_matrix_source);
16035 
16039  MatrixKit(float const in_matrix_source[]);
16040 
16043  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
16044 
16046  virtual ~MatrixKit();
16047 
16050  static MatrixKit GetDefault();
16051 
16055  bool Equals(MatrixKit const & in_kit) const;
16056 
16060  bool operator==(MatrixKit const & in_kit) const;
16061 
16065  bool operator!=(MatrixKit const & in_kit) const;
16066 
16070  bool ShowDeterminant(float & out_determinant) const;
16071 
16075  bool ShowInverse(MatrixKit & out_matrix) const;
16076 
16081  bool ShowAdjoint(MatrixKit & out_matrix) const;
16082 
16086  MatrixKit & UnsetEverything();
16087 
16089  void Reset();
16090 
16094  bool Empty() const;
16095 
16098  void Set(MatrixKit const & other);
16099 
16105  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
16106 
16111  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
16112 
16116  bool ShowElements(FloatArray & out_matrix) const;
16117 
16118 #ifndef HPS_GULP_CLANG
16119 
16122  bool ShowElements(float out_matrix[]) const;
16123 #endif
16124 
16130  bool Compose(Vector const & in_translation, Vector const & in_scale, Quaternion const & in_rotation);
16131 
16137  bool Decompose(Vector & out_translation, Vector & out_scale, Quaternion & out_rotation) const;
16138 
16144  MatrixKit & Rotate(float in_x, float in_y, float in_z);
16145 
16150  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
16151 
16157  MatrixKit & Translate(float in_x, float in_y, float in_z);
16158 
16162  MatrixKit & Translate(Vector const & in_translation);
16163 
16169  MatrixKit & Scale(float in_x, float in_y, float in_z);
16170 
16174  MatrixKit & Concatenate(MatrixKit const & in_kit);
16175 
16178  MatrixKit & Normalize();
16179 
16182  MatrixKit & Invert();
16183 
16187  MatrixKit & Adjoint();
16188 
16191  bool IsIdentity() const;
16192 
16196  MatrixKit Multiply(MatrixKit const & in_right) const;
16197 
16201  MatrixKit & MultiplyAndAssign(MatrixKit const & in_right);
16202 
16206  MatrixKit Multiply(float in_scalar) const;
16207 
16211  MatrixKit & MultiplyAndAssign(float in_scalar);
16212 
16218  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
16219 
16224  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
16225 
16229  MatrixKit & SetElements(FloatArray const & in_values);
16230 
16235  MatrixKit & SetElements(size_t in_value_count, float const in_values[]);
16236 
16240  Point Transform(Point const & in_source) const;
16241 
16245  PointArray Transform(PointArray const & in_source) const;
16246 
16251  PointArray Transform(size_t in_count, Point const in_source[]) const;
16252 
16256  Vector Transform(Vector const & in_source) const;
16257 
16261  VectorArray Transform(VectorArray const & in_source) const;
16262 
16267  VectorArray Transform(size_t in_count, Vector const in_source[]) const;
16268 
16272  Plane Transform(Plane const & in_source) const;
16273 
16277  PlaneArray Transform(PlaneArray const & in_source) const;
16278 
16283  PlaneArray Transform(size_t in_count, Plane const in_source[]) const;
16284 
16288  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
16289 
16293  SimpleSphere Transform(SimpleSphere const & in_source) const;
16294 
16298  MatrixKit & operator=(MatrixKit const & in_kit);
16299 
16303  MatrixKit operator*(MatrixKit const & in_right) const;
16304 
16308  MatrixKit const & operator*=(MatrixKit const & in_right);
16309 
16313  MatrixKit operator*(float in_scalar) const;
16314 
16318  MatrixKit const & operator*=(float in_scalar);
16319 };
16320 
16324 class HPS_API ModellingMatrixControl : public Control
16325 {
16326 public:
16327 
16329  explicit ModellingMatrixControl(SegmentKey const & in_seg);
16330 
16332  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
16333 
16336 
16341 
16345  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
16346 
16349 
16350  virtual HPS::Type Type() const { return ObjectType(); }
16351 
16352  static const HPS::Type staticType = HPS::Type::ModellingMatrixControl;
16353  HPS::Type ObjectType() const {return staticType;};
16354 
16358  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
16359 
16362  ModellingMatrixControl & Set(MatrixKit const & in_matrix);
16363 
16369  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
16370 
16375  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
16376 
16380  ModellingMatrixControl & SetElements(FloatArray const & in_values);
16381 
16386  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
16387 
16388 
16391  ModellingMatrixControl & UnsetEverything();
16392 
16395  bool Show(MatrixKit & out_matrix) const;
16396 
16402  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
16403 
16408  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
16409 
16413  bool ShowElements(FloatArray & out_matrix) const;
16414 
16418  bool ShowDeterminant(float & out_determinant) const;
16419 
16423  bool ShowInverse(MatrixKit & out_matrix) const;
16424 
16429  bool ShowAdjoint(MatrixKit & out_matrix) const;
16430 
16436  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
16437 
16442  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
16443 
16449  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
16450 
16454  ModellingMatrixControl & Translate(Vector const & in_translation);
16455 
16461  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
16462 
16466  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
16467 
16470  ModellingMatrixControl & Normalize();
16471 
16474  ModellingMatrixControl & Invert();
16475 
16479  ModellingMatrixControl & Adjoint();
16480 
16481 private:
16484 };
16485 
16488 class HPS_API TextureMatrixControl : public Control
16489 {
16490 public:
16491 
16493  explicit TextureMatrixControl(SegmentKey & in_seg);
16494 
16496  TextureMatrixControl(const TextureMatrixControl & in_that);
16497 
16502 
16506  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
16507 
16510 
16511  virtual HPS::Type Type() const { return ObjectType(); }
16512 
16513  static const HPS::Type staticType = HPS::Type::TextureMatrixControl;
16514  HPS::Type ObjectType() const {return staticType;};
16515 
16519  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
16520 
16523  TextureMatrixControl & Set(MatrixKit const & in_matrix);
16524 
16530  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
16531 
16536  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
16537 
16541  TextureMatrixControl & SetElements(FloatArray const & in_values);
16542 
16547  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
16548 
16549 
16552  TextureMatrixControl & UnsetEverything();
16553 
16554 
16557  bool Show(MatrixKit & out_matrix) const;
16558 
16564  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
16565 
16570  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
16571 
16575  bool ShowElements(FloatArray & out_matrix) const;
16576 
16580  bool ShowDeterminant(float & out_determinant) const;
16581 
16585  bool ShowInverse(MatrixKit & out_matrix) const;
16586 
16591  bool ShowAdjoint(MatrixKit & out_matrix) const;
16592 
16598  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
16599 
16604  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
16605 
16611  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
16612 
16618  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
16619 
16623  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
16624 
16627  TextureMatrixControl & Normalize();
16628 
16631  TextureMatrixControl & Invert();
16632 
16636  TextureMatrixControl & Adjoint();
16637 
16638 private:
16641 };
16642 
16643 
16646 class HPS_API MaterialMappingKit : public Kit
16647 {
16648 public:
16649 
16652 
16655  MaterialMappingKit(MaterialMappingKit const & in_kit);
16656 
16661 
16665  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
16666 
16668  ~MaterialMappingKit();
16669 
16670  static const HPS::Type staticType = HPS::Type::MaterialMappingKit;
16671  HPS::Type ObjectType() const {return staticType;};
16672 
16676  static MaterialMappingKit GetDefault();
16677 
16680  void Set(MaterialMappingKit const & in_kit);
16681 
16684  void Show(MaterialMappingKit & out_kit) const;
16685 
16689  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
16690 
16693  bool Empty() const;
16694 
16698  bool Equals(MaterialMappingKit const & in_kit) const;
16699 
16703  bool operator==(MaterialMappingKit const & in_kit) const;
16704 
16708  bool operator!=(MaterialMappingKit const & in_kit) const;
16709 
16710  //Set
16711 
16715  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
16716 
16722  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
16723 
16724 
16728  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
16729 
16735  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
16736 
16742  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16743 
16748  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
16749 
16756  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16757 
16766  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);
16767 
16771  MaterialMappingKit & SetBackFaceGloss(float in_value);
16772 
16776  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
16777 
16782  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
16783 
16789  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16790 
16795  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
16796 
16803  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16804 
16813  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);
16814 
16818  MaterialMappingKit & SetFrontFaceGloss(float in_value);
16819 
16823  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
16824 
16829  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
16830 
16831 
16835  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
16836 
16842  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
16843 
16849  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16850 
16855  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
16856 
16863  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16864 
16873  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);
16874 
16878  MaterialMappingKit & SetCutFaceGloss(float in_value);
16879 
16883  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
16884 
16889  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
16890 
16895  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
16896 
16902  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16903 
16910  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16911 
16920  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);
16921 
16925  MaterialMappingKit & SetEdgeGloss(float in_value);
16926 
16930  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
16931 
16936  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
16937 
16942  MaterialMappingKit & SetFaceAlpha(float in_alpha);
16943 
16949  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16950 
16957  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16958 
16967  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);
16968 
16972  MaterialMappingKit & SetFaceGloss(float in_value);
16973 
16977  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
16978 
16983  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
16984 
16988  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
16989 
16990 
16991 
16992 
16993 
16997  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
16998 
17004  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
17005 
17006 
17010  MaterialMappingKit & SetLineAlpha(float in_alpha);
17011 
17017  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
17018 
17024  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
17025 
17026 
17030  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
17031 
17037  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
17038 
17039 
17043  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
17044 
17050  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
17051 
17056  MaterialMappingKit & SetVertexAlpha(float in_alpha);
17057 
17063  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17064 
17071  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17072 
17081  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);
17082 
17086  MaterialMappingKit & SetVertexGloss(float in_value);
17087 
17091  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
17092 
17097  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
17098 
17102  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
17103 
17104 
17108  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
17109 
17115  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
17116 
17117 
17121  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
17122 
17128  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
17129 
17130  //Aggregate Sets
17131 
17135  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
17136 
17141  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
17142 
17143 
17147  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
17148 
17154  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
17155 
17156  //Aggregate set
17157 
17161  MaterialMappingKit & SetGeometryColor(RGBAColor const & in_rgba_color);
17162 
17163  //Unset
17164 
17167  MaterialMappingKit & UnsetAmbientLightUpColor();
17168 
17169 
17172  MaterialMappingKit & UnsetAmbientLightDownColor();
17173 
17174 
17177  MaterialMappingKit & UnsetBackFaceMaterial();
17178 
17181  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
17182 
17185  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
17186 
17189  MaterialMappingKit & UnsetFrontFaceMaterial();
17190 
17193  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
17194 
17197  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
17198 
17199 
17200 
17203  MaterialMappingKit & UnsetCutEdgeColor();
17204 
17205 
17208  MaterialMappingKit & UnsetCutFaceMaterial();
17209 
17212  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
17213 
17216  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
17217 
17218 
17221  MaterialMappingKit & UnsetEdgeMaterial();
17222 
17225  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
17226 
17229  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
17230 
17231 
17234  MaterialMappingKit & UnsetFaceMaterial();
17235 
17238  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
17239 
17242  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
17243 
17244 
17247  MaterialMappingKit & UnsetLightColor();
17248 
17249 
17252  MaterialMappingKit & UnsetLineAlpha();
17253 
17257  MaterialMappingKit & UnsetLineColor();
17258 
17259 
17262  MaterialMappingKit & UnsetMarkerColor();
17263 
17264 
17267  MaterialMappingKit & UnsetTextColor();
17268 
17269 
17272  MaterialMappingKit & UnsetVertexMaterial();
17273 
17276  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
17277 
17280  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
17281 
17282 
17285  MaterialMappingKit & UnsetWindowColor();
17286 
17287 
17290  MaterialMappingKit & UnsetWindowContrastColor();
17291 
17292 
17293  //Aggregate Unsets
17294 
17297  MaterialMappingKit & UnsetCutGeometryColor();
17298 
17301  MaterialMappingKit & UnsetAmbientLightColor();
17302 
17305  MaterialMappingKit & UnsetEverything();
17306 
17307 
17308  //Show
17309 
17315  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17316 
17322  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17323 
17324 
17333  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17334 
17344  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;
17345 
17351  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17352 
17353 
17362  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17363 
17373  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;
17374 
17380  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17381 
17382 
17383 
17389  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17390 
17391 
17399  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17400 
17409  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;
17410 
17416  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17417 
17418 
17426  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17427 
17436  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;
17437 
17443  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17444 
17445 
17454  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17455 
17465  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;
17466 
17472  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17473 
17474 
17480  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17481 
17482 
17486  bool ShowLineAlpha(float & out_alpha) const;
17487 
17488 
17494  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17495 
17496 
17502  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17503 
17504 
17510  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17511 
17512 
17520  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17521 
17530  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;
17531 
17537  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17538 
17539 
17545  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17546 
17547 
17553  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17554 };
17555 
17556 
17557 
17559 class HPS_API PBRMaterialKit : public Kit
17560 {
17561 public:
17562 
17564  PBRMaterialKit();
17565 
17568  PBRMaterialKit(PBRMaterialKit const & in_kit);
17569 
17573  PBRMaterialKit(PBRMaterialKit && in_that);
17574 
17578  PBRMaterialKit & operator=(PBRMaterialKit && in_that);
17579 
17581  ~PBRMaterialKit();
17582 
17583  static const HPS::Type staticType = HPS::Type::PBRMaterialKit;
17584  HPS::Type ObjectType() const { return staticType; };
17585 
17589  static PBRMaterialKit GetDefault();
17590 
17593  void Set(PBRMaterialKit const & in_kit);
17594 
17597  void Show(PBRMaterialKit & out_kit) const;
17598 
17602  PBRMaterialKit & operator=(PBRMaterialKit const & in_kit);
17603 
17606  bool Empty() const;
17607 
17611  bool Equals(PBRMaterialKit const & in_kit) const;
17612 
17616  bool operator==(PBRMaterialKit const & in_kit) const;
17617 
17621  bool operator!=(PBRMaterialKit const & in_kit) const;
17622 
17623  //Set
17624 
17628  PBRMaterialKit & SetBaseColorMap(char const * in_texture_name);
17629 
17633  PBRMaterialKit & SetNormalMap(char const * in_texture_name);
17634 
17638  PBRMaterialKit & SetEmissiveMap(char const * in_texture_name);
17639 
17644  PBRMaterialKit & SetMetalnessMap(char const * in_texture_name, HPS::Material::Texture::ChannelMapping in_channel = HPS::Material::Texture::ChannelMapping::Red);
17645 
17650  PBRMaterialKit & SetRoughnessMap(char const * in_texture_name, HPS::Material::Texture::ChannelMapping in_channel = HPS::Material::Texture::ChannelMapping::Green);
17651 
17656  PBRMaterialKit & SetOcclusionMap(char const * in_texture_name, HPS::Material::Texture::ChannelMapping in_channel = HPS::Material::Texture::ChannelMapping::Blue);
17657 
17661  PBRMaterialKit & SetBaseColorFactor(HPS::RGBAColor const & in_color);
17662 
17666  PBRMaterialKit & SetNormalFactor(float in_factor);
17667 
17671  PBRMaterialKit & SetMetalnessFactor(float in_factor);
17672 
17676  PBRMaterialKit & SetRoughnessFactor(float in_factor);
17677 
17681  PBRMaterialKit & SetOcclusionFactor(float in_factor);
17682 
17687  PBRMaterialKit & SetAlphaFactor(float in_factor, bool in_mask = false);
17688 
17689  //Unset
17692  PBRMaterialKit & UnsetBaseColorMap();
17693 
17696  PBRMaterialKit & UnsetNormalMap();
17697 
17700  PBRMaterialKit & UnsetEmissiveMap();
17701 
17704  PBRMaterialKit & UnsetMetalnessMap();
17705 
17708  PBRMaterialKit & UnsetRoughnessMap();
17709 
17712  PBRMaterialKit & UnsetOcclusionMap();
17713 
17716  PBRMaterialKit & UnsetBaseColorFactor();
17717 
17720  PBRMaterialKit & UnsetNormalFactor();
17721 
17724  PBRMaterialKit & UnsetMetalnessFactor();
17725 
17728  PBRMaterialKit & UnsetRoughnessFactor();
17729 
17732  PBRMaterialKit & UnsetOcclusionFactor();
17733 
17736  PBRMaterialKit & UnsetAlphaFactor();
17737 
17740  PBRMaterialKit & UnsetEverything();
17741 
17742  //Show
17743 
17747  bool ShowBaseColorMap(UTF8 & out_texture_name) const;
17748 
17752  bool ShowNormalMap(UTF8 & out_texture_name) const;
17753 
17757  bool ShowEmissiveMap(UTF8 & out_texture_name) const;
17758 
17763  bool ShowMetalnessMap(UTF8 & out_texture_name, HPS::Material::Texture::ChannelMapping & out_channel) const;
17764 
17769  bool ShowRoughnessMap(UTF8 & out_texture_name, HPS::Material::Texture::ChannelMapping & out_channel) const;
17770 
17775  bool ShowOcclusionMap(UTF8 & out_texture_name, HPS::Material::Texture::ChannelMapping & out_channel) const;
17776 
17780  bool ShowBaseColorFactor(HPS::RGBAColor & out_color) const;
17781 
17785  bool ShowNormalFactor(float & out_factor) const;
17786 
17790  bool ShowMetalnessFactor(float & out_factor) const;
17791 
17795  bool ShowRoughnessFactor(float & out_factor) const;
17796 
17800  bool ShowOcclusionFactor(float & out_factor) const;
17801 
17806  bool ShowAlphaFactor(float & out_factor, bool & out_mask) const;
17807 };
17808 
17809 
17815 class HPS_API MaterialMappingControl : public Control
17816 {
17817 public:
17818 
17820  explicit MaterialMappingControl(SegmentKey & in_seg);
17821 
17824 
17829 
17833  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
17834 
17837 
17838  virtual HPS::Type Type() const { return ObjectType(); }
17839 
17840  static const HPS::Type staticType = HPS::Type::MaterialMappingControl;
17841  HPS::Type ObjectType() const {return staticType;};
17842 
17846  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
17847 
17848  //Set
17849 
17853  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
17854 
17860  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
17861 
17862 
17866  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
17867 
17873  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
17874 
17879  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
17880 
17886  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17887 
17894  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17895 
17904  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);
17905 
17909  MaterialMappingControl & SetBackFaceGloss(float in_value);
17910 
17914  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
17915 
17920  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
17921 
17922 
17927  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
17928 
17934  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17935 
17942  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17943 
17952  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);
17953 
17957  MaterialMappingControl & SetFrontFaceGloss(float in_value);
17958 
17962  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
17963 
17968  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
17969 
17973  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
17974 
17980  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
17981 
17986  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
17987 
17993  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17994 
18001  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
18002 
18011  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);
18012 
18016  MaterialMappingControl & SetCutFaceGloss(float in_value);
18017 
18021  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
18022 
18027  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
18028 
18033  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
18034 
18040  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
18041 
18048  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
18049 
18058  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);
18059 
18063  MaterialMappingControl & SetEdgeGloss(float in_value);
18064 
18068  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
18069 
18074  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
18075 
18081  MaterialMappingControl & SetFaceAlpha(float in_alpha);
18082 
18089  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
18090 
18097  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
18098 
18107  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);
18108 
18112  MaterialMappingControl & SetFaceGloss(float in_value);
18113 
18117  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
18118 
18123  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
18124 
18128  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
18129 
18130 
18134  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
18135 
18141  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
18142 
18146  MaterialMappingControl & SetLineAlpha(float in_alpha);
18147 
18153  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
18154 
18160  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
18161 
18162 
18166  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
18167 
18173  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
18174 
18175 
18179  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
18180 
18186  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
18187 
18188 
18193  MaterialMappingControl & SetVertexAlpha(float in_alpha);
18194 
18195 
18201  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
18202 
18209  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
18210 
18219  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);
18220 
18224  MaterialMappingControl & SetVertexGloss(float in_value);
18225 
18229  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
18230 
18235  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
18236 
18240  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
18241 
18242 
18246  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
18247 
18253  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
18254 
18255 
18259  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
18260 
18266  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
18267 
18268  //Aggregate Sets
18269 
18273  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
18274 
18279  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
18280 
18281 
18285  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
18286 
18292  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
18293 
18294 
18295  //Aggregate set
18296 
18300  MaterialMappingControl & SetGeometryColor(RGBAColor const & in_rgba_color);
18301 
18302 
18303  //Unset
18304 
18308  MaterialMappingControl & UnsetAmbientLightUpColor();
18309 
18310 
18314  MaterialMappingControl & UnsetAmbientLightDownColor();
18315 
18316 
18320  MaterialMappingControl & UnsetFrontFaceMaterial();
18321 
18325  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
18326 
18330  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
18331 
18332 
18336  MaterialMappingControl & UnsetBackFaceMaterial();
18337 
18341  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
18342 
18346  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
18347 
18348 
18352  MaterialMappingControl & UnsetCutEdgeColor();
18353 
18354 
18358  MaterialMappingControl & UnsetCutFaceMaterial();
18359 
18363  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
18364 
18368  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
18369 
18370 
18374  MaterialMappingControl & UnsetEdgeMaterial();
18375 
18379  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
18380 
18384  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
18385 
18386 
18390  MaterialMappingControl & UnsetFaceMaterial();
18391 
18395  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
18396 
18400  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
18401 
18402 
18406  MaterialMappingControl & UnsetLightColor();
18407 
18408 
18412  MaterialMappingControl & UnsetLineAlpha();
18413 
18418  MaterialMappingControl & UnsetLineColor();
18419 
18420 
18424  MaterialMappingControl & UnsetMarkerColor();
18425 
18426 
18430  MaterialMappingControl & UnsetTextColor();
18431 
18432 
18436  MaterialMappingControl & UnsetVertexMaterial();
18437 
18441  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
18442 
18446  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
18447 
18448 
18452  MaterialMappingControl & UnsetWindowColor();
18453 
18454 
18458  MaterialMappingControl & UnsetWindowContrastColor();
18459 
18460 
18461  //Aggregate Unsets
18462 
18466  MaterialMappingControl & UnsetCutGeometryColor();
18467 
18471  MaterialMappingControl & UnsetAmbientLightColor();
18472 
18476  MaterialMappingControl & UnsetEverything();
18477 
18478 
18479  //Show
18480 
18486  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18487 
18488 
18494  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18495 
18496 
18505  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18506 
18516  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;
18517 
18523  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18524 
18525 
18534  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18535 
18545  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;
18546 
18552  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18553 
18554 
18560  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18561 
18562 
18570  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18571 
18580  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;
18581 
18587  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18588 
18589 
18597  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18598 
18607  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;
18608 
18614  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18615 
18616 
18625  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18626 
18636  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;
18637 
18643  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18644 
18645 
18651  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18652 
18653 
18657  bool ShowLineAlpha(float & out_alpha) const;
18658 
18664  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18665 
18666 
18672  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18673 
18674 
18680  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18681 
18682 
18690  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
18691 
18700  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;
18701 
18707  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
18708 
18709 
18715  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18716 
18717 
18723  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
18724 
18725 private:
18727 };
18728 
18729 
18732 class HPS_API PortfolioControl : public Control
18733 {
18734 public:
18736  explicit PortfolioControl(SegmentKey & in_seg);
18737 
18739  PortfolioControl(PortfolioControl const & in_that);
18740 
18744  PortfolioControl(PortfolioControl && in_that);
18745 
18749  PortfolioControl & operator=(PortfolioControl && in_that);
18750 
18752  ~PortfolioControl();
18753 
18754  virtual HPS::Type Type() const { return ObjectType(); }
18755 
18756  static const HPS::Type staticType = HPS::Type::PortfolioControl;
18757  HPS::Type ObjectType() const { return staticType; };
18758 
18762  PortfolioControl & operator=(PortfolioControl const & in_that);
18763 
18765  size_t GetCount() const;
18766 
18767 
18772  PortfolioControl & Push(PortfolioKey const & in_portfolio);
18773 
18776  bool Pop();
18777 
18781  bool Pop(PortfolioKey & out_portfolio);
18782 
18783 
18787  PortfolioControl & Set(PortfolioKey const & in_portfolio);
18788 
18792  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
18793 
18798  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
18799 
18800 
18803  PortfolioControl & UnsetTop();
18804 
18807  PortfolioControl & UnsetEverything();
18808 
18809 
18813  bool ShowTop(PortfolioKey & out_portfolio) const;
18814 
18818  bool Show(PortfolioKeyArray & out_portfolios) const;
18819 
18820 private:
18821  PortfolioControl();
18822 };
18823 
18824 
18825 
18828 class HPS_API StyleControl : public Control
18829 {
18830 public:
18832  explicit StyleControl(SegmentKey & in_seg);
18833 
18835  StyleControl(StyleControl const & in_that);
18836 
18840  StyleControl(StyleControl && in_that);
18841 
18845  StyleControl & operator=(StyleControl && in_that);
18846 
18848  ~StyleControl();
18849 
18850  virtual HPS::Type Type() const { return ObjectType(); }
18851 
18852  static const HPS::Type staticType = HPS::Type::StyleControl;
18853  HPS::Type ObjectType() const { return staticType; };
18854 
18858  StyleControl & operator=(StyleControl const & in_that);
18859 
18861  size_t GetCount() const;
18862 
18864  StyleKey PushNamed(char const * in_style_name);
18865 
18871  StyleKey PushNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
18872 
18879  StyleKey AppendNamed(char const * in_style_name, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
18880 
18885  StyleKey PushSegment(SegmentKey const & in_style_source);
18886 
18892  StyleKey PushSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
18893 
18900  StyleKey AppendSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
18901 
18902 
18903 
18906  bool Pop();
18907 
18914  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional);
18915 
18919  void Flush(SegmentKey const & in_style_source);
18920 
18927  void Flush(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
18928 
18932  void Flush(char const * in_style_name);
18933 
18940  void Flush(char const * in_style_name, ConditionalExpression const & in_conditional);
18941 
18942 
18945  StyleKey SetNamed(char const * in_style_name);
18946 
18950  StyleKey SetNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
18951 
18952 
18955  StyleKey SetSegment(SegmentKey const & in_style_source);
18956 
18960  StyleKey SetSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
18961 
18962 
18968  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionalExpressionArray const & in_conditions);
18969 
18974  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
18975 
18982  void Set(size_t in_count, Style::Type const in_types[], SegmentKey const in_segment_sources[], UTF8 const in_style_names[], ConditionalExpression const in_conditions[]);
18983 
18984 
18985 
18987  void UnsetTop();
18988 
18990  void UnsetAllSegment();
18991 
18993  void UnsetAllNamed();
18994 
18996  void UnsetEverything();
18997 
18998 
19005  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional) const;
19006 
19010  bool ShowTop(StyleKey & out_style) const;
19011 
19018  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionalExpressionArray & out_conditions) const;
19019 
19023  bool Show(StyleKeyArray & out_styles) const;
19024 
19029  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionalExpressionArray & out_conditions) const;
19030 
19034  bool ShowAllSegment(StyleKeyArray & out_styles) const;
19035 
19040  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionalExpressionArray & out_conditions) const;
19041 
19045  bool ShowAllNamed(StyleKeyArray & out_styles) const;
19046 
19047 private:
19048  StyleControl();
19049 };
19050 
19051 
19054 class HPS_API ConditionControl : public Control
19055 {
19056 public:
19058  explicit ConditionControl(SegmentKey & in_seg);
19059 
19061  ConditionControl(ConditionControl const & in_that);
19062 
19066  ConditionControl(ConditionControl && in_that);
19067 
19071  ConditionControl & operator=(ConditionControl && in_that);
19072 
19074  ~ConditionControl();
19075 
19076  virtual HPS::Type Type() const { return ObjectType(); }
19077 
19078  static const HPS::Type staticType = HPS::Type::ConditionControl;
19079  HPS::Type ObjectType() const { return staticType; };
19080 
19084  ConditionControl & operator=(ConditionControl const & in_that);
19085 
19088  size_t GetCount() const;
19089 
19093  ConditionControl & AddCondition(char const * in_condition);
19094 
19095 
19099  ConditionControl & SetCondition(char const * in_condition);
19100 
19104  ConditionControl & SetConditions(UTF8Array const & in_conditions);
19105 
19110  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
19111 
19112 
19116  ConditionControl & UnsetCondition(char const * in_condition);
19117 
19120  ConditionControl & UnsetEverything();
19121 
19122 
19126  bool ShowCondition(char const * in_condition) const;
19127 
19131  bool ShowConditions(UTF8Array & out_conditions) const;
19132 
19133 private:
19135  ConditionControl();
19136 };
19137 
19138 
19141 class HPS_API MaterialKit : public Kit
19142 {
19143 public:
19144 
19146  MaterialKit();
19147 
19150  MaterialKit(MaterialKit const & in_kit);
19151 
19155  MaterialKit(MaterialKit && in_that);
19156 
19160  MaterialKit & operator=(MaterialKit && in_that);
19161 
19163  ~MaterialKit();
19164 
19165  static const HPS::Type staticType = HPS::Type::MaterialKit;
19166  HPS::Type ObjectType() const {return staticType;};
19167 
19170  void Set(MaterialKit const & in_kit);
19171 
19174  void Show(MaterialKit & out_kit) const;
19175 
19179  MaterialKit & operator=(MaterialKit const & in_kit);
19180 
19183  bool Empty() const;
19184 
19188  bool Equals(MaterialKit const & in_kit) const;
19189 
19193  bool operator==(MaterialKit const & in_kit) const;
19194 
19198  bool operator!=(MaterialKit const & in_kit) const;
19199 
19200 
19201  //Set
19202 
19206  MaterialKit & SetDiffuse(RGBColor const & in_color);
19207 
19211  MaterialKit & SetDiffuse(RGBAColor const & in_color);
19212 
19216  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
19217 
19221  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
19222 
19227  MaterialKit & SetDiffuseAlpha(float in_alpha);
19228 
19235  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
19236 
19244  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
19245 
19250  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
19251 
19257  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
19258 
19265  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
19266 
19274  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
19275 
19276 
19280  MaterialKit & SetShader(char const * in_shader_name);
19281 
19282 
19283 
19287  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
19288 
19292  MaterialKit & SetSpecular(char const * in_texture_name);
19293 
19298  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
19299 
19300 
19301 
19305  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
19306 
19310  MaterialKit & SetMirror(char const * in_texture_name);
19311 
19316  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
19317 
19318 
19319 
19323  MaterialKit & SetTransmission(char const * in_texture_name);
19324 
19329  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
19330 
19331 
19332 
19336  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
19337 
19341  MaterialKit & SetEmission(char const * in_texture_name);
19342 
19347  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
19348 
19349 
19350 
19354  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
19355 
19360  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
19361 
19365  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
19366 
19371  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
19372 
19375  MaterialKit & SetEnvironmentTexture();
19376 
19377 
19381  MaterialKit & SetBump(char const * in_texture_name);
19382 
19383 
19384 
19391  MaterialKit & SetGloss(float in_gloss);
19392 
19395  MaterialKit & UnsetDiffuseColorRGB();
19396 
19399  MaterialKit & UnsetDiffuseColor();
19400 
19403  MaterialKit & UnsetDiffuseAlpha();
19404 
19407  MaterialKit & UnsetDiffuseTexture();
19408 
19412  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
19413 
19416  MaterialKit & UnsetShader();
19417 
19420  MaterialKit & UnsetSpecular();
19421 
19424  MaterialKit & UnsetMirror();
19425 
19428  MaterialKit & UnsetTransmission();
19429 
19432  MaterialKit & UnsetEmission();
19433 
19436  MaterialKit & UnsetEnvironment();
19437 
19440  MaterialKit & UnsetBump();
19441 
19444  MaterialKit & UnsetGloss();
19445 
19448  MaterialKit & UnsetEverything();
19449 
19450 
19453  bool ShowDiffuse() const;
19454 
19458  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
19459 
19463  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
19464 
19468  bool ShowDiffuseAlpha(float & out_alpha) const;
19469 
19476  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19477 
19485  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19486 
19493  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
19494 
19498  bool ShowShader(UTF8 & out_shader_name) const;
19499 
19508  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19509 
19518  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19519 
19520 
19521 
19530  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19531 
19532 
19541  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19542 
19543 
19552  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
19553 
19554 
19558  bool ShowBump(UTF8 & out_texture_name) const;
19559 
19564  bool ShowGloss(float & out_gloss) const;
19565 };
19566 
19567 
19569 class HPS_API NURBSSurfaceAttributeKit : public Kit
19570 {
19571 public:
19572 
19575 
19579 
19584 
19588  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
19589 
19591  virtual ~NURBSSurfaceAttributeKit();
19592 
19593  static const HPS::Type staticType = HPS::Type::NURBSSurfaceAttributeKit;
19594  HPS::Type ObjectType() const {return staticType;};
19595 
19599  static NURBSSurfaceAttributeKit GetDefault();
19600 
19603  void Set(NURBSSurfaceAttributeKit const & in_kit);
19604 
19607  void Show(NURBSSurfaceAttributeKit & out_kit) const;
19608 
19612  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
19613 
19616  bool Empty() const;
19617 
19621  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
19622 
19626  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
19627 
19631  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
19632 
19633 
19637  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
19638 
19643  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
19644 
19648  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
19649 
19653  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
19654 
19658  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
19659 
19664  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
19665 
19666 
19669  NURBSSurfaceAttributeKit & UnsetBudget();
19670 
19673  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
19674 
19677  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
19678 
19681  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
19682 
19685  NURBSSurfaceAttributeKit & UnsetTrimBudget();
19686 
19689  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
19690 
19693  NURBSSurfaceAttributeKit & UnsetEverything();
19694 
19698  bool ShowBudget(size_t & out_budget) const;
19699 
19703  bool ShowMaximumDeviation(float & out_deviation) const;
19704 
19708  bool ShowMaximumAngle(float & out_degrees) const;
19709 
19713  bool ShowMaximumWidth(float & out_width) const;
19714 
19718  bool ShowTrimBudget(size_t & out_budget) const;
19719 
19723  bool ShowMaximumTrimDeviation(float & out_deviation) const;
19724 };
19725 
19732 {
19733 public:
19734 
19736  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
19737 
19740 
19745 
19750 
19753 
19754  virtual HPS::Type Type() const { return ObjectType(); }
19755 
19756  static const HPS::Type staticType = HPS::Type::NURBSSurfaceAttributeControl;
19757  HPS::Type ObjectType() const {return staticType;};
19758 
19762  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
19763 
19767  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
19768 
19773  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
19774 
19778  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
19779 
19783  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
19784 
19788  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
19789 
19794  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
19795 
19796 
19800  NURBSSurfaceAttributeControl & UnsetBudget();
19801 
19805  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
19806 
19810  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
19811 
19815  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
19816 
19820  NURBSSurfaceAttributeControl & UnsetTrimBudget();
19821 
19825  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
19826 
19830  NURBSSurfaceAttributeControl & UnsetEverything();
19831 
19832 
19836  bool ShowBudget(size_t & out_budget) const;
19837 
19841  bool ShowMaximumDeviation(float & out_deviation) const;
19842 
19846  bool ShowMaximumAngle(float & out_degrees) const;
19847 
19851  bool ShowMaximumWidth(float & out_width) const;
19852 
19856  bool ShowTrimBudget(size_t & out_budget) const;
19857 
19861  bool ShowMaximumTrimDeviation(float & out_deviation) const;
19862 
19863 private:
19866 };
19867 
19868 
19869 
19871 class HPS_API PerformanceKit : public Kit
19872 {
19873 public:
19874 
19876  PerformanceKit();
19877 
19880  PerformanceKit(PerformanceKit const & in_kit);
19881 
19885  PerformanceKit(PerformanceKit && in_that);
19886 
19890  PerformanceKit & operator=(PerformanceKit && in_that);
19891 
19893  virtual ~PerformanceKit();
19894 
19895  static const HPS::Type staticType = HPS::Type::PerformanceKit;
19896  HPS::Type ObjectType() const {return staticType;};
19897 
19901  static PerformanceKit GetDefault();
19902 
19905  void Set(PerformanceKit const & in_kit);
19906 
19909  void Show(PerformanceKit & out_kit) const;
19910 
19914  PerformanceKit & operator=(PerformanceKit const & in_kit);
19915 
19918  bool Empty() const;
19919 
19923  bool Equals(PerformanceKit const & in_kit) const;
19924 
19928  bool operator==(PerformanceKit const & in_kit) const;
19929 
19933  bool operator!=(PerformanceKit const & in_kit) const;
19934 
19935 
19940 
19944  PerformanceKit & SetTextHardwareAcceleration(bool in_state);
19945 
19950  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
19951 
19955  PerformanceKit & SetStaticConditions(Performance::StaticConditions in_conditions);
19956 
19957 
19960  PerformanceKit & UnsetDisplayLists();
19961 
19964  PerformanceKit & UnsetTextHardwareAcceleration();
19965 
19968  PerformanceKit & UnsetStaticModel();
19969 
19972  PerformanceKit & UnsetStaticConditions();
19973 
19976  PerformanceKit & UnsetEverything();
19977 
19981  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
19982 
19986  bool ShowTextHardwareAcceleration(bool & out_state) const;
19987 
19991  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
19992 
19996  bool ShowStaticConditions(Performance::StaticConditions & out_conditions) const;
19997 };
19998 
19999 
20005 class HPS_API PerformanceControl : public Control
20006 {
20007 public:
20008 
20010  explicit PerformanceControl(SegmentKey & in_seg);
20011 
20013  PerformanceControl(PerformanceControl const & in_that);
20014 
20019 
20023  PerformanceControl & operator=(PerformanceControl && in_that);
20024 
20026  ~PerformanceControl();
20027 
20028  virtual HPS::Type Type() const { return ObjectType(); }
20029 
20030  static const HPS::Type staticType = HPS::Type::PerformanceControl;
20031  HPS::Type ObjectType() const {return staticType;};
20032 
20036  PerformanceControl & operator=(PerformanceControl const & in_that);
20037 
20042 
20046  PerformanceControl & SetTextHardwareAcceleration(bool in_state);
20047 
20052  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
20053 
20057  PerformanceControl & SetStaticConditions(Performance::StaticConditions in_conditions);
20058 
20059 
20063  PerformanceControl & UnsetDisplayLists();
20064 
20068  PerformanceControl & UnsetTextHardwareAcceleration();
20069 
20073  PerformanceControl & UnsetStaticModel();
20074 
20078  PerformanceControl & UnsetStaticConditions();
20079 
20083  PerformanceControl & UnsetEverything();
20084 
20085 
20089  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
20090 
20094  bool ShowTextHardwareAcceleration(bool & out_state) const;
20095 
20099  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
20100 
20104  bool ShowStaticConditions(Performance::StaticConditions & out_conditions) const;
20105 
20106 private:
20109 };
20110 
20111 
20112 
20114 class HPS_API HiddenLineAttributeKit : public Kit
20115 {
20116 public:
20117 
20120 
20124 
20129 
20133  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
20134 
20136  virtual ~HiddenLineAttributeKit();
20137 
20138  static const HPS::Type staticType = HPS::Type::HiddenLineAttributeKit;
20139  HPS::Type ObjectType() const {return staticType;};
20140 
20144  static HiddenLineAttributeKit GetDefault();
20145 
20148  void Set(HiddenLineAttributeKit const & in_kit);
20149 
20152  void Show(HiddenLineAttributeKit & out_kit) const;
20153 
20157  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
20158 
20161  bool Empty() const;
20162 
20166  bool Equals(HiddenLineAttributeKit const & in_kit) const;
20167 
20171  bool operator==(HiddenLineAttributeKit const & in_kit) const;
20172 
20176  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
20177 
20178 
20183  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
20184 
20188  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
20189 
20195  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
20196 
20207  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
20208 
20212  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
20213 
20227  HiddenLineAttributeKit & SetLineSorting(bool in_state, float in_threshold=2.0f, Line::SizeUnits in_units=HPS::Line::SizeUnits::Pixels);
20228 
20232  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
20233 
20237  HiddenLineAttributeKit & SetRenderText(bool in_state);
20238 
20244  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
20245 
20251  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
20252 
20256  HiddenLineAttributeKit & SetVisibility(bool in_state);
20257 
20262  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20263 
20266  HiddenLineAttributeKit & UnsetAlgorithm();
20267 
20270  HiddenLineAttributeKit & UnsetColor();
20271 
20274  HiddenLineAttributeKit & UnsetDimFactor();
20275 
20278  HiddenLineAttributeKit & UnsetFaceDisplacement();
20279 
20282  HiddenLineAttributeKit & UnsetLinePattern();
20283 
20286  HiddenLineAttributeKit & UnsetLineSorting();
20287 
20290  HiddenLineAttributeKit & UnsetRenderFaces();
20291 
20294  HiddenLineAttributeKit & UnsetRenderText();
20295 
20298  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
20299 
20302  HiddenLineAttributeKit & UnsetTransparencyCutoff();
20303 
20306  HiddenLineAttributeKit & UnsetVisibility();
20307 
20310  HiddenLineAttributeKit & UnsetWeight();
20311 
20314  HiddenLineAttributeKit & UnsetEverything();
20315 
20316 
20320  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
20321 
20325  bool ShowColor(RGBAColor & out_color) const;
20326 
20330  bool ShowDimFactor(float & out_zero_to_one) const;
20331 
20335  bool ShowFaceDisplacement(float & out_buckets) const;
20336 
20340  bool ShowLinePattern(UTF8 & out_pattern) const;
20341 
20347  bool ShowLineSorting(bool & out_state, float & out_threshold, Line::SizeUnits & out_units) const;
20348 
20352  bool ShowRenderFaces(bool & out_state) const;
20353 
20357  bool ShowRenderText(bool & out_state) const;
20358 
20362  bool ShowSilhouetteCleanup(bool & out_state) const;
20363 
20367  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
20368 
20372  bool ShowVisibility(bool & out_state) const;
20373 
20378  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
20379 };
20380 
20381 
20387 class HPS_API HiddenLineAttributeControl : public Control
20388 {
20389 public:
20390 
20392  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
20393 
20396 
20401 
20406 
20409 
20410  virtual HPS::Type Type() const { return ObjectType(); }
20411 
20412  static const HPS::Type staticType = HPS::Type::HiddenLineAttributeControl;
20413  HPS::Type ObjectType() const {return staticType;};
20414 
20418  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
20419 
20424  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
20425 
20429  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
20430 
20436  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
20437 
20448  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
20449 
20453  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
20454 
20467  HiddenLineAttributeControl & SetLineSorting(bool in_on, float in_activation_weight = 2, Line::SizeUnits in_units = Line::SizeUnits::Pixels);
20468 
20472  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
20473 
20477  HiddenLineAttributeControl & SetRenderText(bool in_state);
20478 
20484  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
20485 
20491  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
20492 
20496  HiddenLineAttributeControl & SetVisibility(bool in_state);
20497 
20502  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20503 
20507  HiddenLineAttributeControl & UnsetAlgorithm();
20508 
20512  HiddenLineAttributeControl & UnsetColor();
20513 
20517  HiddenLineAttributeControl & UnsetDimFactor();
20518 
20522  HiddenLineAttributeControl & UnsetFaceDisplacement();
20523 
20527  HiddenLineAttributeControl & UnsetLinePattern();
20528 
20532  HiddenLineAttributeControl & UnsetLineSorting();
20533 
20537  HiddenLineAttributeControl & UnsetRenderFaces();
20538 
20542  HiddenLineAttributeControl & UnsetRenderText();
20543 
20547  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
20548 
20552  HiddenLineAttributeControl & UnsetTransparencyCutoff();
20553 
20557  HiddenLineAttributeControl & UnsetVisibility();
20558 
20562  HiddenLineAttributeControl & UnsetWeight();
20563 
20567  HiddenLineAttributeControl & UnsetEverything();
20568 
20569 
20573  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
20574 
20578  bool ShowColor(RGBAColor & out_color) const;
20579 
20583  bool ShowDimFactor(float & out_zero_to_one) const;
20584 
20588  bool ShowFaceDisplacement(float & out_buckets) const;
20589 
20593  bool ShowLinePattern(UTF8 & out_pattern) const;
20594 
20600  bool ShowLineSorting(bool & out_state, float & out_threshold, Line::SizeUnits & out_units) const;
20601 
20605  bool ShowRenderFaces(bool & out_state) const;
20606 
20610  bool ShowRenderText(bool & out_state) const;
20611 
20615  bool ShowSilhouetteCleanup(bool & out_state) const;
20616 
20620  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
20621 
20625  bool ShowVisibility(bool & out_state) const;
20626 
20631  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
20632 
20633 private:
20636 };
20637 
20638 
20639 
20641 class HPS_API DrawingAttributeKit : public Kit
20642 {
20643 public:
20644 
20647 
20650  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
20651 
20656 
20660  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
20661 
20663  virtual ~DrawingAttributeKit();
20664 
20665  static const HPS::Type staticType = HPS::Type::DrawingAttributeKit;
20666  HPS::Type ObjectType() const {return staticType;};
20667 
20671  static DrawingAttributeKit GetDefault();
20672 
20675  void Set(DrawingAttributeKit const & in_kit);
20676 
20679  void Show(DrawingAttributeKit & out_kit) const;
20680 
20684  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
20685 
20688  bool Empty() const;
20689 
20693  bool Equals(DrawingAttributeKit const & in_kit) const;
20694 
20698  bool operator==(DrawingAttributeKit const & in_kit) const;
20699 
20703  bool operator!=(DrawingAttributeKit const & in_kit) const;
20704 
20720  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
20721 
20727  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
20728 
20741  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
20742 
20751  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
20752 
20759  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
20760 
20769  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
20770 
20777  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
20778 
20787  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
20788 
20794  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
20795 
20799  DrawingAttributeKit & SetVertexDecimation(float in_zero_to_one);
20800 
20804  DrawingAttributeKit & SetVertexRandomization(bool in_state);
20805 
20809  DrawingAttributeKit & SetOverrideInternalColor(VisibilityKit const & in_kit);
20810 
20814  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
20815 
20820  DrawingAttributeKit & SetDeferral(int in_deferral);
20821 
20828 
20835  DrawingAttributeKit & SetClipRegion(size_t in_point_count, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
20836 
20843 
20846  DrawingAttributeKit & UnsetPolygonHandedness();
20847 
20850  DrawingAttributeKit & UnsetWorldHandedness();
20851 
20854  DrawingAttributeKit & UnsetDepthRange();
20855 
20858  DrawingAttributeKit & UnsetFaceDisplacement();
20859 
20862  DrawingAttributeKit & UnsetGeneralDisplacement();
20863 
20866  DrawingAttributeKit & UnsetVertexDisplacement();
20867 
20870  DrawingAttributeKit & UnsetVertexDecimation();
20871 
20874  DrawingAttributeKit & UnsetVertexRandomization();
20875 
20878  DrawingAttributeKit & UnsetOverrideInternalColor();
20879 
20882  DrawingAttributeKit & UnsetOverlay();
20883 
20886  DrawingAttributeKit & UnsetDeferral();
20887 
20890  DrawingAttributeKit & UnsetClipRegion();
20891 
20894  DrawingAttributeKit & UnsetEverything();
20895 
20899  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
20900 
20904  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
20905 
20910  bool ShowDepthRange(float & out_near, float & out_far) const;
20911 
20916  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
20917 
20922  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
20923 
20928  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
20929 
20933  bool ShowVertexDecimation(float & out_zero_to_one) const;
20934 
20938  bool ShowVertexRandomization(bool & out_state) const;
20939 
20943  bool ShowOverrideInternalColor(VisibilityKit & out_kit) const;
20944 
20948  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
20949 
20953  bool ShowDeferral(int & out_defer_batch) const;
20954 
20960  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
20961 
20962 };
20963 
20964 
20981 class HPS_API DrawingAttributeControl : public Control
20982 {
20983 public:
20984 
20986  explicit DrawingAttributeControl(SegmentKey & in_seg);
20987 
20990 
20995 
20999  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
21000 
21003 
21004  virtual HPS::Type Type() const { return ObjectType(); }
21005 
21006  static const HPS::Type staticType = HPS::Type::DrawingAttributeControl;
21007  HPS::Type ObjectType() const {return staticType;};
21008 
21012  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
21013 
21023  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
21024 
21030  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
21031 
21044  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
21045 
21054  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
21055 
21062  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
21063 
21072  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
21073 
21080  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
21081 
21090  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
21091 
21097  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
21098 
21102  DrawingAttributeControl & SetVertexDecimation(float in_zero_to_one);
21103 
21107  DrawingAttributeControl & SetVertexRandomization(bool in_state);
21108 
21112  DrawingAttributeControl & SetOverrideInternalColor(VisibilityKit const & in_kit);
21113 
21117  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
21118 
21125 
21132  DrawingAttributeControl & SetClipRegion(size_t in_point_count, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
21133 
21140 
21145  DrawingAttributeControl & SetDeferral(int in_deferral);
21146 
21150  DrawingAttributeControl & UnsetPolygonHandedness();
21151 
21155  DrawingAttributeControl & UnsetWorldHandedness();
21156 
21160  DrawingAttributeControl & UnsetDepthRange();
21161 
21165  DrawingAttributeControl & UnsetFaceDisplacement();
21166 
21170  DrawingAttributeControl & UnsetGeneralDisplacement();
21171 
21175  DrawingAttributeControl & UnsetVertexDisplacement();
21176 
21180  DrawingAttributeControl & UnsetVertexDecimation();
21181 
21185  DrawingAttributeControl & UnsetVertexRandomization();
21186 
21190  DrawingAttributeControl & UnsetOverrideInternalColor();
21191 
21195  DrawingAttributeControl & UnsetOverlay();
21196 
21200  DrawingAttributeControl & UnsetDeferral();
21201 
21205  DrawingAttributeControl & UnsetClipRegion();
21206 
21210  DrawingAttributeControl & UnsetEverything();
21211 
21212 
21216  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
21217 
21221  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
21222 
21227  bool ShowDepthRange(float & out_x, float & out_y) const;
21228 
21233  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
21234 
21239  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
21240 
21245  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
21246 
21250  bool ShowVertexDecimation(float & out_zero_to_one) const;
21251 
21255  bool ShowVertexRandomization(bool & out_state) const;
21256 
21260  bool ShowOverrideInternalColor(VisibilityKit & out_kit) const;
21261 
21265  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
21266 
21270  bool ShowDeferral(int & out_defer_batch) const;
21271 
21277  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
21278 
21279 private:
21282 };
21283 
21284 
21286 class HPS_API PostProcessEffectsKit : public Kit
21287 {
21288 public:
21289 
21292 
21296 
21301 
21305  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
21306 
21308  virtual ~PostProcessEffectsKit();
21309 
21310  static const HPS::Type staticType = HPS::Type::PostProcessEffectsKit;
21311  HPS::Type ObjectType() const {return staticType;};
21312 
21316  static PostProcessEffectsKit GetDefault();
21317 
21320  void Set(PostProcessEffectsKit const & in_kit);
21321 
21324  void Show(PostProcessEffectsKit & out_kit) const;
21325 
21329  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
21330 
21333  bool Empty() const;
21334 
21338  bool Equals(PostProcessEffectsKit const & in_kit) const;
21339 
21343  bool operator==(PostProcessEffectsKit const & in_kit) const;
21344 
21348  bool operator!=(PostProcessEffectsKit const & in_kit) const;
21349 
21350 
21362  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21363 
21374  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21375 
21382  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
21383 
21389  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
21390 
21397  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
21398 
21404  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
21405 
21413  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
21414 
21421  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
21422 
21430  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
21431 
21438  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
21439 
21443  PostProcessEffectsKit & SetWorldScale(float in_scale);
21444 
21447  PostProcessEffectsKit & UnsetAmbientOcclusion();
21448 
21451  PostProcessEffectsKit & UnsetBloom();
21452 
21455  PostProcessEffectsKit & UnsetDepthOfField();
21456 
21459  PostProcessEffectsKit & UnsetSilhouetteEdges();
21460 
21463  PostProcessEffectsKit & UnsetEyeDomeLighting();
21464 
21467  PostProcessEffectsKit & UnsetWorldScale();
21468 
21471  PostProcessEffectsKit & UnsetEverything();
21472 
21473 
21483  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality, float & out_radius, float & out_sharpness) const;
21484 
21491  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
21492 
21499  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
21500 
21508  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
21509 
21517  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
21518 
21522  bool ShowWorldScale(float & out_scale) const;
21523 
21524 };
21525 
21526 
21530 class HPS_API PostProcessEffectsControl : public Control
21531 {
21532 public:
21533 
21535  explicit PostProcessEffectsControl(WindowKey & in_seg);
21536 
21539 
21544 
21548  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
21549 
21552 
21553  virtual HPS::Type Type() const { return ObjectType(); }
21554 
21555  static const HPS::Type staticType = HPS::Type::PostProcessEffectsControl;
21556  HPS::Type ObjectType() const {return staticType;};
21557 
21561  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
21562 
21574  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21575 
21586  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f, float in_sharpness = 32.0f);
21587 
21594  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
21595 
21601  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
21602 
21609  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
21610 
21616  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
21617 
21625  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
21626 
21633  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
21634 
21642  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
21643 
21650  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
21651 
21655  PostProcessEffectsControl & SetWorldScale(float in_scale);
21656 
21660  PostProcessEffectsControl & UnsetAmbientOcclusion();
21661 
21665  PostProcessEffectsControl & UnsetBloom();
21666 
21670  PostProcessEffectsControl & UnsetDepthOfField();
21671 
21675  PostProcessEffectsControl & UnsetSilhouetteEdges();
21676 
21680  PostProcessEffectsControl & UnsetEyeDomeLighting();
21681 
21685  PostProcessEffectsControl & UnsetWorldScale();
21686 
21690  PostProcessEffectsControl & UnsetEverything();
21691 
21692 
21702  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality, float & out_radius, float & out_sharpness) const;
21703 
21710  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
21711 
21718  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
21719 
21727  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
21728 
21736  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
21737 
21741  bool ShowWorldScale(float & out_scale) const;
21742 
21743 private:
21746 };
21747 
21749 class HPS_API TransformMaskKit : public Kit
21750 {
21751 public:
21752 
21754  TransformMaskKit();
21755 
21757  TransformMaskKit(TransformMaskKit const & in_kit);
21758 
21762  TransformMaskKit(TransformMaskKit && in_that);
21763 
21767  TransformMaskKit & operator=(TransformMaskKit && in_that);
21768 
21770  virtual ~TransformMaskKit();
21771 
21772  static const HPS::Type staticType = HPS::Type::TransformMaskKit;
21773  HPS::Type ObjectType() const {return staticType;};
21774 
21775  static TransformMaskKit GetDefault();
21776 
21778  void Set(TransformMaskKit const & in_kit);
21779 
21781  void Show(TransformMaskKit & out_kit) const;
21782 
21784  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
21785 
21787  bool Empty() const;
21788 
21790  bool Equals(TransformMaskKit const & in_kit) const;
21791 
21793  bool operator==(TransformMaskKit const & in_kit) const;
21794 
21796  bool operator!=(TransformMaskKit const & in_kit) const;
21797 
21798 
21802  TransformMaskKit & SetCameraRotation(bool in_state);
21803 
21807  TransformMaskKit & SetCameraScale(bool in_state);
21808 
21812  TransformMaskKit & SetCameraTranslation(bool in_state);
21813 
21817  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
21818 
21822  TransformMaskKit & SetCameraProjection(bool in_state);
21823 
21827  TransformMaskKit & SetCameraOffset(bool in_state);
21828 
21832  TransformMaskKit & SetCameraNearLimit(bool in_state);
21833 
21837  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
21838 
21842  TransformMaskKit & SetModellingMatrixScale(bool in_state);
21843 
21847  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
21848 
21852  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
21853 
21854 
21858  TransformMaskKit & SetCameraEverything(bool in_state);
21859 
21863  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
21864 
21868  TransformMaskKit & SetEverything(bool in_state);
21869 
21870 
21873  TransformMaskKit & UnsetCameraRotation();
21874 
21877  TransformMaskKit & UnsetCameraScale();
21878 
21881  TransformMaskKit & UnsetCameraTranslation();
21882 
21885  TransformMaskKit & UnsetCameraPerspectiveScale();
21886 
21889  TransformMaskKit & UnsetCameraProjection();
21890 
21893  TransformMaskKit & UnsetCameraOffset();
21894 
21897  TransformMaskKit & UnsetCameraNearLimit();
21898 
21901  TransformMaskKit & UnsetCameraEverything();
21902 
21905  TransformMaskKit & UnsetModellingMatrixRotation();
21906 
21909  TransformMaskKit & UnsetModellingMatrixScale();
21910 
21913  TransformMaskKit & UnsetModellingMatrixTranslation();
21914 
21917  TransformMaskKit & UnsetModellingMatrixOffset();
21918 
21921  TransformMaskKit & UnsetModellingMatrixEverything();
21922 
21925  TransformMaskKit & UnsetEverything();
21926 
21927 
21931  bool ShowCameraRotation(bool & out_state) const;
21932 
21936  bool ShowCameraScale(bool & out_state) const;
21937 
21941  bool ShowCameraTranslation(bool & out_state) const;
21942 
21946  bool ShowCameraPerspectiveScale(bool & out_state) const;
21947 
21951  bool ShowCameraProjection(bool & out_state) const;
21952 
21956  bool ShowCameraOffset(bool & out_state) const;
21957 
21961  bool ShowCameraNearLimit(bool & out_state) const;
21962 
21966  bool ShowModellingMatrixRotation(bool & out_state) const;
21967 
21971  bool ShowModellingMatrixScale(bool & out_state) const;
21972 
21976  bool ShowModellingMatrixTranslation(bool & out_state) const;
21977 
21981  bool ShowModellingMatrixOffset(bool & out_state) const;
21982 };
21983 
21984 
21989 class HPS_API TransformMaskControl : public Control
21990 {
21991 public:
21992 
21994  explicit TransformMaskControl(SegmentKey & in_seg);
21995 
21997  TransformMaskControl(TransformMaskControl const & in_that);
21998 
22003 
22007  TransformMaskControl & operator=(TransformMaskControl && in_that);
22008 
22011 
22012  virtual HPS::Type Type() const { return ObjectType(); }
22013 
22014  static const HPS::Type staticType = HPS::Type::TransformMaskControl;
22015  HPS::Type ObjectType() const {return staticType;};
22016 
22020  TransformMaskControl & operator=(TransformMaskControl const & in_that);
22021 
22025  TransformMaskControl & SetCameraRotation(bool in_state);
22026 
22030  TransformMaskControl & SetCameraScale(bool in_state);
22031 
22035  TransformMaskControl & SetCameraTranslation(bool in_state);
22036 
22040  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
22041 
22045  TransformMaskControl & SetCameraProjection(bool in_state);
22046 
22050  TransformMaskControl & SetCameraOffset(bool in_state);
22051 
22055  TransformMaskControl & SetCameraNearLimit(bool in_state);
22056 
22060  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
22061 
22065  TransformMaskControl & SetModellingMatrixScale(bool in_state);
22066 
22070  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
22071 
22075  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
22076 
22077 
22081  TransformMaskControl & SetCameraEverything(bool in_state);
22082 
22086  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
22087 
22091  TransformMaskControl & SetEverything(bool in_state);
22092 
22093 
22097  TransformMaskControl & UnsetCameraRotation();
22098 
22102  TransformMaskControl & UnsetCameraScale();
22103 
22107  TransformMaskControl & UnsetCameraTranslation();
22108 
22112  TransformMaskControl & UnsetCameraPerspectiveScale();
22113 
22117  TransformMaskControl & UnsetCameraProjection();
22118 
22122  TransformMaskControl & UnsetCameraOffset();
22123 
22127  TransformMaskControl & UnsetCameraNearLimit();
22128 
22132  TransformMaskControl & UnsetCameraEverything();
22133 
22137  TransformMaskControl & UnsetModellingMatrixRotation();
22138 
22142  TransformMaskControl & UnsetModellingMatrixScale();
22143 
22147  TransformMaskControl & UnsetModellingMatrixTranslation();
22148 
22152  TransformMaskControl & UnsetModellingMatrixOffset();
22153 
22157  TransformMaskControl & UnsetModellingMatrixEverything();
22158 
22162  TransformMaskControl & UnsetEverything();
22163 
22164 
22168  bool ShowCameraRotation(bool & out_state) const;
22169 
22173  bool ShowCameraScale(bool & out_state) const;
22174 
22178  bool ShowCameraTranslation(bool & out_state) const;
22179 
22183  bool ShowCameraPerspectiveScale(bool & out_state) const;
22184 
22188  bool ShowCameraProjection(bool & out_state) const;
22189 
22193  bool ShowCameraOffset(bool & out_state) const;
22194 
22198  bool ShowCameraNearLimit(bool & out_state) const;
22199 
22203  bool ShowModellingMatrixRotation(bool & out_state) const;
22204 
22208  bool ShowModellingMatrixScale(bool & out_state) const;
22209 
22213  bool ShowModellingMatrixTranslation(bool & out_state) const;
22214 
22218  bool ShowModellingMatrixOffset(bool & out_state) const;
22219 
22220 private:
22223 };
22224 
22225 
22226 
22228 class HPS_API VisualEffectsKit : public Kit
22229 {
22230 public:
22231 
22233  VisualEffectsKit();
22234 
22237  VisualEffectsKit(VisualEffectsKit const & in_kit);
22238 
22242  VisualEffectsKit(VisualEffectsKit && in_that);
22243 
22247  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
22248 
22250  virtual ~VisualEffectsKit();
22251 
22252  static const HPS::Type staticType = HPS::Type::VisualEffectsKit;
22253  HPS::Type ObjectType() const {return staticType;};
22254 
22258  static VisualEffectsKit GetDefault();
22259 
22262  void Set(VisualEffectsKit const & in_kit);
22263 
22266  void Show(VisualEffectsKit & out_kit) const;
22267 
22271  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
22272 
22275  bool Empty() const;
22276 
22280  bool Equals(VisualEffectsKit const & in_kit) const;
22281 
22285  bool operator==(VisualEffectsKit const & in_kit) const;
22286 
22290  bool operator!=(VisualEffectsKit const & in_kit) const;
22291 
22295  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
22296 
22300  VisualEffectsKit & SetAmbientOcclusionEnabled(bool in_state);
22301 
22305  VisualEffectsKit & SetBloomEnabled(bool in_state);
22306 
22310  VisualEffectsKit & SetDepthOfFieldEnabled(bool in_state);
22311 
22315  VisualEffectsKit & SetSilhouetteEdgesEnabled(bool in_state);
22316 
22320  VisualEffectsKit & SetEyeDomeLightingEnabled(bool in_state);
22321 
22327  VisualEffectsKit & SetEyeDomeLightingBackColor(bool in_state, RGBColor const & in_color = RGBColor::Black());
22328 
22333  VisualEffectsKit & SetEyeDomeLightingBackColor(RGBColor const & in_color);
22334 
22339  VisualEffectsKit & SetAntiAliasing(bool in_state);
22340 
22344  VisualEffectsKit & SetTextAntiAliasing(bool in_state);
22345 
22355  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
22356 
22365  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
22366 
22373  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
22374 
22380  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
22381 
22385  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22386 
22390  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
22391 
22395  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
22396 
22407  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);
22408 
22418  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
22419 
22423  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22424 
22428  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
22429 
22432  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
22433 
22436  VisualEffectsKit & UnsetAmbientOcclusionEnabled();
22437 
22440  VisualEffectsKit & UnsetSilhouetteEdgesEnabled();
22441 
22444  VisualEffectsKit & UnsetDepthOfFieldEnabled();
22445 
22448  VisualEffectsKit & UnsetBloomEnabled();
22449 
22452  VisualEffectsKit & UnsetEyeDomeLightingEnabled();
22453 
22456  VisualEffectsKit & UnsetEyeDomeLightingBackColor();
22457 
22461  VisualEffectsKit & UnsetAntiAliasing();
22462 
22465  VisualEffectsKit & UnsetTextAntiAliasing();
22466 
22469  VisualEffectsKit & UnsetShadowMaps();
22470 
22473  VisualEffectsKit & UnsetSimpleShadow();
22474 
22477  VisualEffectsKit & UnsetSimpleShadowPlane();
22478 
22481  VisualEffectsKit & UnsetSimpleShadowLightDirection();
22482 
22485  VisualEffectsKit & UnsetSimpleShadowColor();
22486 
22489  VisualEffectsKit & UnsetSimpleReflection();
22490 
22493  VisualEffectsKit & UnsetSimpleReflectionPlane();
22494 
22497  VisualEffectsKit & UnsetSimpleReflectionVisibility();
22498 
22501  VisualEffectsKit & UnsetEverything();
22502 
22506  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
22507 
22511  bool ShowAmbientOcclusionEnabled(bool & out_state) const;
22512 
22516  bool ShowSilhouetteEdgesEnabled(bool & out_state) const;
22517 
22521  bool ShowDepthOfFieldEnabled(bool & out_state) const;
22522 
22526  bool ShowBloomEnabled(bool & out_state) const;
22527 
22531  bool ShowEyeDomeLightingEnabled(bool & out_state) const;
22532 
22537  bool ShowEyeDomeLightingBackColor(bool & out_state, RGBColor & out_color) const;
22538 
22543  bool ShowAntiAliasing(bool & out_state) const;
22544 
22548  bool ShowTextAntiAliasing(bool & out_state) const;
22549 
22557  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
22558 
22565  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
22566 
22570  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
22571 
22575  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
22576 
22580  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
22581 
22590  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;
22591 
22592 
22596  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
22597 
22601  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
22602 };
22603 
22604 
22610 class HPS_API VisualEffectsControl : public Control
22611 {
22612 public:
22613 
22615  explicit VisualEffectsControl(SegmentKey & in_seg);
22616 
22618  VisualEffectsControl(VisualEffectsControl const & in_that);
22619 
22624 
22628  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
22629 
22632 
22633  virtual HPS::Type Type() const { return ObjectType(); }
22634 
22635  static const HPS::Type staticType = HPS::Type::VisualEffectsControl;
22636  HPS::Type ObjectType() const {return staticType;};
22637 
22641  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
22642 
22646  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
22647 
22651  VisualEffectsControl & SetAmbientOcclusionEnabled(bool in_state);
22652 
22656  VisualEffectsControl & SetSilhouetteEdgesEnabled(bool in_state);
22657 
22661  VisualEffectsControl & SetDepthOfFieldEnabled(bool in_state);
22662 
22666  VisualEffectsControl & SetBloomEnabled(bool in_state);
22667 
22671  VisualEffectsControl & SetEyeDomeLightingEnabled(bool in_state);
22672 
22678  VisualEffectsControl & SetEyeDomeLightingBackColor(bool in_state, RGBColor const & in_color = RGBColor::Black());
22679 
22684  VisualEffectsControl & SetEyeDomeLightingBackColor(RGBColor const & in_color);
22685 
22690  VisualEffectsControl & SetAntiAliasing(bool in_state);
22691 
22695  VisualEffectsControl & SetTextAntiAliasing(bool in_state);
22696 
22706  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
22707 
22716  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
22717 
22724  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
22725 
22731  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
22732 
22736  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22737 
22741  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
22742 
22746  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
22747 
22758  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);
22759 
22769  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
22770 
22774  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
22775 
22779  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
22780 
22781 
22785  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
22786 
22790  VisualEffectsControl & UnsetAmbientOcclusionEnabled();
22791 
22795  VisualEffectsControl & UnsetSilhouetteEdgesEnabled();
22796 
22800  VisualEffectsControl & UnsetDepthOfFieldEnabled();
22801 
22805  VisualEffectsControl & UnsetBloomEnabled();
22806 
22810  VisualEffectsControl & UnsetEyeDomeLightingEnabled();
22811 
22815  VisualEffectsControl & UnsetEyeDomeLightingBackColor();
22816 
22821  VisualEffectsControl & UnsetAntiAliasing();
22822 
22826  VisualEffectsControl & UnsetTextAntiAliasing();
22827 
22831  VisualEffectsControl & UnsetShadowMaps();
22832 
22836  VisualEffectsControl & UnsetSimpleShadow();
22837 
22841  VisualEffectsControl & UnsetSimpleShadowPlane();
22842 
22846  VisualEffectsControl & UnsetSimpleShadowLightDirection();
22847 
22851  VisualEffectsControl & UnsetSimpleShadowColor();
22852 
22856  VisualEffectsControl & UnsetSimpleReflection();
22857 
22861  VisualEffectsControl & UnsetSimpleReflectionPlane();
22862 
22866  VisualEffectsControl & UnsetSimpleReflectionVisibility();
22867 
22871  VisualEffectsControl & UnsetEverything();
22872 
22873 
22877  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
22878 
22882  bool ShowAmbientOcclusionEnabled(bool & out_state) const;
22883 
22887  bool ShowSilhouetteEdgesEnabled(bool & out_state) const;
22888 
22892  bool ShowDepthOfFieldEnabled(bool & out_state) const;
22893 
22897  bool ShowBloomEnabled(bool & out_state) const;
22898 
22902  bool ShowEyeDomeLightingEnabled(bool & out_state) const;
22903 
22908  bool ShowEyeDomeLightingBackColor(bool & out_state, RGBColor & out_color) const;
22909 
22914  bool ShowAntiAliasing(bool & out_state) const;
22915 
22919  bool ShowTextAntiAliasing(bool & out_state) const;
22920 
22928  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
22929 
22936  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
22937 
22941  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
22942 
22946  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
22947 
22951  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
22952 
22961  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;
22962 
22966  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
22967 
22971  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
22972 
22973 private:
22976 };
22977 
22978 
22979 
22981 class HPS_API ContourLineKit : public Kit
22982 {
22983 public:
22984 
22986  ContourLineKit();
22987 
22990  ContourLineKit(ContourLineKit const & in_kit);
22991 
22995  ContourLineKit(ContourLineKit && in_that);
22996 
23000  ContourLineKit & operator=(ContourLineKit && in_that);
23001 
23003  virtual ~ContourLineKit();
23004 
23005  static const HPS::Type staticType = HPS::Type::ContourLineKit;
23006  HPS::Type ObjectType() const { return staticType; };
23007 
23011  static ContourLineKit GetDefault();
23012 
23015  void Set(ContourLineKit const & in_kit);
23016 
23019  void Show(ContourLineKit & out_kit) const;
23020 
23024  ContourLineKit & operator=(ContourLineKit const & in_kit);
23025 
23028  bool Empty() const;
23029 
23033  bool Equals(ContourLineKit const & in_kit) const;
23034 
23038  bool operator==(ContourLineKit const & in_kit) const;
23039 
23043  bool operator!=(ContourLineKit const & in_kit) const;
23044 
23045 
23049  ContourLineKit & SetVisibility(bool in_state);
23050 
23055  ContourLineKit & SetPositions(float in_interval, float in_offset);
23056 
23060  ContourLineKit & SetPositions(FloatArray const & in_positions);
23061 
23066  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
23067 
23071  ContourLineKit & SetColors(RGBColorArray const & in_colors);
23072 
23077  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
23078 
23082  ContourLineKit & SetColors(RGBColor const & in_color);
23083 
23087  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
23088 
23093  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
23094 
23098  ContourLineKit & SetPatterns(char const * in_pattern);
23099 
23104  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
23105 
23111  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
23112 
23117  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
23118 
23122  ContourLineKit & SetLighting(bool in_state);
23123 
23124 
23127  ContourLineKit & UnsetVisibility();
23128 
23131  ContourLineKit & UnsetPositions();
23132 
23135  ContourLineKit & UnsetColors();
23136 
23139  ContourLineKit & UnsetPatterns();
23140 
23143  ContourLineKit & UnsetWeights();
23144 
23147  ContourLineKit & UnsetLighting();
23148 
23151  ContourLineKit & UnsetEverything();
23152 
23153 
23157  bool ShowVisibility(bool & out_state) const;
23158 
23164  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
23165 
23169  bool ShowColors(RGBColorArray & out_colors) const;
23170 
23174  bool ShowPatterns(UTF8Array & out_patterns) const;
23175 
23180  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
23181 
23185  bool ShowLighting(bool & out_state) const;
23186 };
23187 
23191 class HPS_API ContourLineControl : public Control
23192 {
23193 public:
23194 
23196  explicit ContourLineControl(SegmentKey & in_seg);
23197 
23199  ContourLineControl(ContourLineControl const & in_that);
23200 
23205 
23209  ContourLineControl & operator=(ContourLineControl && in_that);
23210 
23212  ~ContourLineControl();
23213 
23214  virtual HPS::Type Type() const { return ObjectType(); }
23215 
23216  static const HPS::Type staticType = HPS::Type::ContourLineControl;
23217  HPS::Type ObjectType() const { return staticType; };
23218 
23222  ContourLineControl & operator=(ContourLineControl const & in_that);
23223 
23227  ContourLineControl & SetVisibility(bool in_state);
23228 
23233  ContourLineControl & SetPositions(float in_interval, float in_offset);
23234 
23238  ContourLineControl & SetPositions(FloatArray const & in_positions);
23239 
23244  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
23245 
23249  ContourLineControl & SetColors(RGBColorArray const & in_colors);
23250 
23255  ContourLineControl & SetColors(size_t in_count, RGBColor const in_colors[]);
23256 
23260  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
23261 
23265  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
23266 
23271  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
23272 
23276  ContourLineControl & SetPatterns(char const * in_pattern);
23277 
23282  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
23283 
23289  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
23290 
23295  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
23296 
23300  ContourLineControl & SetLighting(bool in_state);
23301 
23302 
23306  ContourLineControl & UnsetVisibility();
23307 
23311  ContourLineControl & UnsetPositions();
23312 
23316  ContourLineControl & UnsetColors();
23317 
23321  ContourLineControl & UnsetPatterns();
23322 
23326  ContourLineControl & UnsetWeights();
23327 
23331  ContourLineControl & UnsetLighting();
23332 
23336  ContourLineControl & UnsetEverything();
23337 
23338 
23342  bool ShowVisibility(bool & out_state) const;
23343 
23349  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
23350 
23354  bool ShowColors(RGBColorArray & out_colors) const;
23355 
23359  bool ShowPatterns(UTF8Array & out_patterns) const;
23360 
23365  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
23366 
23370  bool ShowLighting(bool & out_state) const;
23371 
23372 private:
23375 };
23376 
23377 
23378 
23380 class HPS_API SubwindowKit : public Kit
23381 {
23382 public:
23383 
23385  SubwindowKit();
23386 
23388  SubwindowKit(SubwindowKit const & in_kit);
23389 
23393  SubwindowKit(SubwindowKit && in_that);
23394 
23398  SubwindowKit & operator=(SubwindowKit && in_that);
23399 
23401  virtual ~SubwindowKit();
23402 
23403  static const HPS::Type staticType = HPS::Type::SubwindowKit;
23404  HPS::Type ObjectType() const {return staticType;}
23405 
23409  static SubwindowKit GetDefault();
23410 
23413  void Set(SubwindowKit const & in_kit);
23414 
23417  void Show(SubwindowKit & out_kit) const;
23418 
23422  SubwindowKit & operator=(SubwindowKit const & in_kit);
23423 
23426  bool Empty() const;
23427 
23431  bool Equals(SubwindowKit const & in_kit) const;
23432 
23436  bool operator==(SubwindowKit const & in_kit) const;
23437 
23441  bool operator!=(SubwindowKit const & in_kit) const;
23442 
23443 
23453  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
23454 
23455 
23466  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, IntRectangle const & in_subwindow_offsets, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
23467 
23468 
23475  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
23476 
23481  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
23482 
23487  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
23488 
23494  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
23495 
23500  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
23501 
23504  SubwindowKit & UnsetSubwindow();
23505 
23508  SubwindowKit & UnsetBackground();
23509 
23512  SubwindowKit & UnsetBorder();
23513 
23516  SubwindowKit & UnsetRenderingAlgorithm();
23517 
23520  SubwindowKit & UnsetModelCompareMode();
23521 
23524  SubwindowKit & UnsetEverything();
23525 
23531  bool ShowSubwindow(Rectangle & out_subwindow_position, IntRectangle & out_subwindow_offsets, Subwindow::Type & out_subwindow_type) const;
23532 
23537  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
23538 
23542  bool ShowBorder(Subwindow::Border & out_border_type) const;
23543 
23547  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
23548 
23554  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
23555 };
23556 
23557 
23558 
23564 class HPS_API SubwindowControl : public Control
23565 {
23566 public:
23567 
23569  explicit SubwindowControl(SegmentKey & in_seg);
23570 
23572  SubwindowControl(SubwindowControl const & in_that);
23573 
23577  SubwindowControl(SubwindowControl && in_that);
23578 
23582  SubwindowControl & operator=(SubwindowControl && in_that);
23583 
23585  ~SubwindowControl();
23586 
23587  virtual HPS::Type Type() const { return ObjectType(); }
23588 
23589  static const HPS::Type staticType = HPS::Type::SubwindowControl;
23590  HPS::Type ObjectType() const {return staticType;}
23591 
23595  SubwindowControl & operator=(SubwindowControl const & in_that);
23596 
23607  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
23608 
23620  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, IntRectangle const & in_window_offsets, Subwindow::Type in_type = Subwindow::Type::Standard);
23621 
23628  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
23629 
23634  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
23635 
23641  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
23642 
23648  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
23649 
23654  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
23655 
23659  SubwindowControl & UnsetSubwindow();
23660 
23664  SubwindowControl & UnsetBackground();
23665 
23669  SubwindowControl & UnsetBorder();
23670 
23674  SubwindowControl & UnsetRenderingAlgorithm();
23675 
23679  SubwindowControl & UnsetModelCompareMode();
23680 
23684  SubwindowControl & UnsetEverything();
23685 
23691  bool ShowSubwindow(Rectangle & out_subwindow_position, IntRectangle & out_subwindow_offsets, Subwindow::Type & out_subwindow_type) const;
23692 
23697  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
23698 
23702  bool ShowBorder(Subwindow::Border & out_border_type) const;
23703 
23707  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
23708 
23714  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
23715 
23716 private:
23718  SubwindowControl();
23719 };
23720 
23721 
23722 
23724 class HPS_API DebuggingKit : public Kit
23725 {
23726 public:
23727 
23729  DebuggingKit();
23730 
23732  DebuggingKit(DebuggingKit const & in_kit);
23733 
23737  DebuggingKit(DebuggingKit && in_that);
23738 
23742  DebuggingKit & operator=(DebuggingKit && in_that);
23743 
23745  virtual ~DebuggingKit();
23746 
23747  static const HPS::Type staticType = HPS::Type::DebuggingKit;
23748  HPS::Type ObjectType() const {return staticType;}
23749 
23753  static DebuggingKit GetDefault();
23754 
23757  void Set(DebuggingKit const & in_kit);
23758 
23761  void Show(DebuggingKit & out_kit) const;
23762 
23766  DebuggingKit & operator=(DebuggingKit const & in_kit);
23767 
23770  bool Empty() const;
23771 
23775  bool Equals(DebuggingKit const & in_kit) const;
23776 
23780  bool operator==(DebuggingKit const & in_kit) const;
23781 
23785  bool operator!=(DebuggingKit const & in_kit) const;
23786 
23787 
23790  DebuggingKit & UnsetEverything();
23791 
23792 
23796  DebuggingKit & SetResourceMonitor(bool in_display);
23797 
23798 
23801  DebuggingKit & UnsetResourceMonitor();
23802 
23806  bool ShowResourceMonitor(bool & out_display) const;
23807 };
23808 
23809 
23812 class HPS_API DebuggingControl : public Control
23813 {
23814 public:
23815 
23817  explicit DebuggingControl(WindowKey & in_window);
23818 
23820  DebuggingControl(DebuggingControl const & in_that);
23821 
23825  DebuggingControl(DebuggingControl && in_that);
23826 
23830  DebuggingControl & operator=(DebuggingControl && in_that);
23831 
23833  ~DebuggingControl();
23834 
23835  virtual HPS::Type Type() const { return ObjectType(); }
23836 
23837  static const HPS::Type staticType = HPS::Type::DebuggingControl;
23838  HPS::Type ObjectType() const {return staticType;}
23839 
23843  DebuggingControl & operator=(DebuggingControl const & in_that);
23844 
23849  DebuggingControl & SetResourceMonitor(bool in_display);
23850 
23854  DebuggingControl & UnsetResourceMonitor();
23855 
23859  DebuggingControl & UnsetEverything();
23860 
23864  bool ShowResourceMonitor(bool & out_display) const;
23865 
23866 private:
23868  DebuggingControl();
23869 };
23870 
23871 
23873 class HPS_API WindowInfoKit : public Kit
23874 {
23875 public:
23876 
23878  WindowInfoKit();
23879 
23881  WindowInfoKit(WindowInfoKit const & in_kit);
23882 
23886  WindowInfoKit(WindowInfoKit && in_that);
23887 
23891  WindowInfoKit & operator=(WindowInfoKit && in_that);
23892 
23894  virtual ~WindowInfoKit();
23895 
23896  static const HPS::Type staticType = HPS::Type::WindowInfoKit;
23897  HPS::Type ObjectType() const {return staticType;}
23898 
23901  void Set(WindowInfoKit const & in_kit);
23902 
23905  void Show(WindowInfoKit & out_kit) const;
23906 
23910  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
23911 
23914  bool Empty() const;
23915 
23919  bool Equals(WindowInfoKit const & in_kit) const;
23920 
23924  bool operator==(WindowInfoKit const & in_kit) const;
23925 
23929  bool operator!=(WindowInfoKit const & in_kit) const;
23930 
23931 
23936  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
23937 
23942  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
23943 
23948  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
23949 
23954  WindowInfoKit & SetWindowSize(float in_width, float in_height);
23955 
23956 
23959  WindowInfoKit & UnsetPhysicalPixels();
23960 
23963  WindowInfoKit & UnsetPhysicalSize();
23964 
23967  WindowInfoKit & UnsetWindowPixels();
23968 
23971  WindowInfoKit & UnsetWindowSize();
23972 
23975  WindowInfoKit & UnsetEverything();
23976 
23977 
23982  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
23983 
23988  bool ShowPhysicalSize(float & out_width, float & out_height) const;
23989 
23994  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
23995 
24000  bool ShowWindowSize(float & out_width, float & out_height) const;
24001 
24007  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
24008 
24012  bool ShowWindowAspectRatio(float & out_window_aspect) const;
24013 
24017  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
24018 };
24019 
24020 
24023 class HPS_API WindowInfoControl : public Control
24024 {
24025 public:
24026 
24028  explicit WindowInfoControl(WindowKey & in_window);
24029 
24031  WindowInfoControl(WindowInfoControl const & in_that);
24032 
24037 
24041  WindowInfoControl & operator=(WindowInfoControl && in_that);
24042 
24044  ~WindowInfoControl();
24045 
24046  virtual HPS::Type Type() const { return ObjectType(); }
24047 
24048  static const HPS::Type staticType = HPS::Type::WindowInfoControl;
24049  HPS::Type ObjectType() const {return staticType;}
24050 
24054  WindowInfoControl & operator=(WindowInfoControl const & in_that);
24055 
24060  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
24061 
24066  bool ShowPhysicalSize(float & out_width, float & out_height) const;
24067 
24072  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
24073 
24078  bool ShowWindowSize(float & out_width, float & out_height) const;
24079 
24085  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
24086 
24090  bool ShowWindowAspectRatio(float & out_window_aspect) const;
24091 
24095  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
24096 
24101  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
24102 
24107  bool ShowLastUpdateTime(Time & out_time) const;
24108 
24112  bool ShowDepthPeelingLayers(size_t & out_layers) const;
24113 
24117  bool ShowVideoMemory(size_t & out_video_memory) const;
24118 
24122  bool ShowDepthBufferSize(size_t & out_bits) const;
24123 
24127  bool ShowMaxLights(size_t & out_lights) const;
24128 
24132  bool ShowColorBitPlanes(size_t & out_planes) const;
24133 
24137  bool ShowLastUpdateInfo(UpdateInfo & out_info) const;
24138 
24142  bool ShowGPUName(UTF8 & out_name) const;
24143 
24144 private:
24147 };
24148 
24150 class HPS_API FontInfoState : public Object
24151 {
24152 public:
24153 
24155  FontInfoState();
24156 
24158  FontInfoState(FontInfoState const & in_kit);
24159 
24163  FontInfoState(FontInfoState && in_that);
24164 
24168  FontInfoState & operator=(FontInfoState && in_that);
24169 
24171  virtual ~FontInfoState();
24172 
24173  static const HPS::Type staticType = HPS::Type::FontInfoState;
24174  HPS::Type ObjectType() const {return staticType;}
24175 
24178  void Assign(FontInfoState const & in_that);
24179 
24182  void Set(FontInfoState const & in_kit);
24183 
24186  void Show(FontInfoState & out_kit) const;
24187 
24191  FontInfoState & operator=(FontInfoState const & in_kit);
24192 
24195  bool Empty() const;
24196 
24200  bool Equals(FontInfoState const & in_kit) const;
24201 
24205  bool operator==(FontInfoState const & in_kit) const;
24206 
24210  bool operator!=(FontInfoState const & in_kit) const;
24211 
24214  UTF8 GetName() const;
24215 
24218  bool ShowSystemName(HPS::UTF8 & out_name) const;
24219 
24222  bool GetShellConvertibility() const;
24223 };
24224 
24225 
24230 class HPS_API AttributeLockKit : public Kit
24231 {
24232 public:
24233 
24235  AttributeLockKit();
24236 
24238  AttributeLockKit(AttributeLockKit const & in_kit);
24239 
24243  AttributeLockKit(AttributeLockKit && in_that);
24244 
24248  AttributeLockKit & operator=(AttributeLockKit && in_that);
24249 
24251  virtual ~AttributeLockKit();
24252 
24253  static const HPS::Type staticType = HPS::Type::AttributeLockKit;
24254  HPS::Type ObjectType() const {return staticType;}
24255 
24259  static AttributeLockKit GetDefault();
24260 
24263  void Set(AttributeLockKit const & in_kit);
24264 
24267  void Show(AttributeLockKit & out_kit) const;
24268 
24272  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
24273 
24276  bool Empty() const;
24277 
24281  bool Equals(AttributeLockKit const & in_kit) const;
24282 
24286  bool operator==(AttributeLockKit const & in_kit) const;
24287 
24291  bool operator!=(AttributeLockKit const & in_kit) const;
24292 
24298  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
24299 
24304  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
24305 
24311  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
24312 
24318  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
24319 
24320 
24323  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24324 
24327  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
24328 
24331  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24332 
24335  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
24336 
24339  AttributeLockKit & UnsetEverything();
24340 
24341 
24346  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
24347 
24352  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24353 
24358  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
24359 
24364  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24365 };
24366 
24367 
24372 class HPS_API AttributeLockControl : public Control
24373 {
24374 public:
24375 
24377  explicit AttributeLockControl(SegmentKey & in_seg);
24378 
24383 
24387  AttributeLockControl & operator=(AttributeLockControl && in_that);
24388 
24390  AttributeLockControl(AttributeLockControl const & in_that);
24391 
24394 
24395  virtual HPS::Type Type() const { return ObjectType(); }
24396 
24397  static const HPS::Type staticType = HPS::Type::AttributeLockControl;
24398  HPS::Type ObjectType() const {return staticType;}
24399 
24403  AttributeLockControl & operator=(AttributeLockControl const & in_that);
24404 
24410  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
24411 
24416  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
24417 
24423  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
24424 
24430  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
24431 
24432 
24436  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24437 
24441  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
24442 
24446  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
24447 
24451  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
24452 
24456  AttributeLockControl & UnsetEverything();
24457 
24458 
24463  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
24464 
24469  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24470 
24475  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
24476 
24481  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
24482 
24483 private:
24486 };
24487 
24491 
24492 class HPS_API GeometryKey : public Key
24493 {
24494 public:
24496  GeometryKey();
24497 
24501  explicit GeometryKey(Key const & in_that);
24502 
24505  GeometryKey(GeometryKey const & in_that);
24506 
24510  GeometryKey & operator=(GeometryKey const & in_that);
24511 
24515  GeometryKey(GeometryKey && in_that);
24516 
24520  GeometryKey & operator=(GeometryKey && in_that);
24521 
24522  ~GeometryKey();
24523 
24524  static const HPS::Type staticType = HPS::Type::GeometryKey;
24525  HPS::Type ObjectType() const { return staticType; };
24526 
24527 
24531  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
24532 
24536  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
24537 
24538 
24539 
24546  GeometryKey & SetPriority(int in_priority);
24547 
24550  GeometryKey & UnsetPriority();
24551 
24555  bool ShowPriority(int & out_priority) const;
24556 
24557 
24563  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24564 
24569  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
24570 
24575  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24576 
24580  GeometryKey & UnsetUserData(intptr_t in_index);
24581 
24586  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24587 
24591  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
24592 
24595  GeometryKey & UnsetAllUserData();
24596 
24598  size_t ShowUserDataCount() const;
24599 
24603  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24604 
24609  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24610 
24615  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24616 
24621  bool ShowBounding(BoundingKit & out_kit) const;
24622 };
24623 
24624 
24626 class HPS_API LineKit : public Kit
24627 {
24628 public:
24630  LineKit();
24631 
24634  LineKit(LineKit const & in_kit);
24635 
24639  LineKit(LineKit && in_that);
24640 
24644  LineKit & operator=(LineKit && in_that);
24645 
24646  virtual ~LineKit();
24647 
24648  static const HPS::Type staticType = HPS::Type::LineKit;
24649  HPS::Type ObjectType() const { return staticType; };
24650 
24653  void Consume(LineKit & in_kit);
24654 
24657  void Set(LineKit const & in_kit);
24658 
24661  void Show(LineKit & out_kit) const;
24662 
24666  LineKit & operator=(LineKit const & in_kit);
24667 
24670  bool Empty() const;
24671 
24675  bool Equals(LineKit const & in_kit) const;
24676 
24680  bool operator==(LineKit const & in_kit) const;
24681 
24685  bool operator!=(LineKit const & in_kit) const;
24686 
24689  size_t GetPointCount() const;
24690 
24697  LineKit & SetPriority(int in_priority);
24698 
24701  LineKit & UnsetPriority();
24702 
24706  bool ShowPriority(int & out_priority) const;
24707 
24708 
24712  LineKit & SetPoints(PointArray const & in_points);
24713 
24718  LineKit & SetPoints(size_t in_count, Point const in_points []);
24719 
24720 
24723  LineKit & UnsetPoints();
24724 
24727  LineKit & UnsetEverything();
24728 
24729 
24733  bool ShowPoints(PointArray & out_points) const;
24734 
24740  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
24741 
24746  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
24747 
24753  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
24754 
24759  LineKit & SetPoints(PointArray const & in_points, LineCoordinateSpaceArray const & in_spaces);
24760 
24766  LineKit & SetPoints(size_t in_count, Point const in_points[], Line::CoordinateSpace const in_spaces[]);
24767 
24768 
24773  bool ShowPoints(PointArray & out_points, LineCoordinateSpaceArray & out_coordinate_spaces) const;
24774 
24780  LineKit & SetPointCoordinateSpace(size_t in_count, size_t const in_indices[], Line::CoordinateSpace const in_spaces[]);
24781 
24786  LineKit & SetPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray const & in_spaces);
24787 
24791  LineKit & SetPointCoordinateSpace(LineCoordinateSpaceArray const & in_spaces);
24792 
24797  LineKit & SetPointCoordinateSpace(size_t in_count, Line::CoordinateSpace const in_spaces[]);
24798 
24802  LineKit & UnsetPointCoordinateSpace(SizeTArray const & in_indices);
24803 
24808  LineKit & UnsetPointCoordinateSpace(size_t in_count, size_t const in_indices[]);
24809 
24812  LineKit & UnsetPointCoordinateSpace();
24813 
24819  bool ShowPointCoordinateSpace(size_t in_count, size_t const in_indices[], LineCoordinateSpaceArray & out_spaces) const;
24820 
24825  bool ShowPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray & out_spaces) const;
24826 
24830  bool ShowPointCoordinateSpace(LineCoordinateSpaceArray & out_spaces) const;
24831 
24837  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
24838 
24843  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
24844 
24849  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
24850 
24856  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
24857 
24863  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
24864 
24870  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24871 
24876  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24877 
24882  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24883 
24887  LineKit & UnsetUserData(intptr_t in_index);
24888 
24893  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24894 
24898  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
24899 
24902  LineKit & UnsetAllUserData();
24903 
24905  size_t ShowUserDataCount() const;
24906 
24910  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24911 
24916  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24917 
24922  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24923 };
24924 
24926 class HPS_API LineKey : public GeometryKey
24927 {
24928 public:
24930  LineKey();
24931 
24935  explicit LineKey(Key const & in_that);
24936 
24939  LineKey(LineKey const & in_that);
24940 
24944  LineKey & operator=(LineKey const & in_that);
24945 
24949  LineKey(LineKey && in_that);
24950 
24954  LineKey & operator=(LineKey && in_that);
24955 
24956  ~LineKey();
24957 
24958  static const HPS::Type staticType = HPS::Type::LineKey;
24959  HPS::Type ObjectType() const { return staticType; };
24960 
24961 
24964  void Consume(LineKit & in_kit);
24965 
24968  void Set(LineKit const & in_kit);
24969 
24972  void Show(LineKit & out_kit) const;
24973 
24976  size_t GetPointCount() const;
24977 
24981  LineKey & SetPoints(PointArray const & in_points);
24982 
24987  LineKey & SetPoints(size_t in_count, Point const in_points []);
24988 
24992  bool ShowPoints(PointArray & out_points) const;
24993 
24999  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25000 
25005  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25006 
25012  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25013 
25018  LineKey & SetPoints(PointArray const & in_points, LineCoordinateSpaceArray const & in_spaces);
25019 
25025  LineKey & SetPoints(size_t in_count, Point const in_points[], Line::CoordinateSpace const in_spaces[]);
25026 
25027 
25032  bool ShowPoints(PointArray & out_points, LineCoordinateSpaceArray & out_coordinate_spaces) const;
25033 
25039  LineKey & SetPointCoordinateSpace(size_t in_count, size_t const in_indices[], Line::CoordinateSpace const in_spaces[]);
25040 
25045  LineKey & SetPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray const & in_spaces);
25046 
25050  LineKey & SetPointCoordinateSpace(LineCoordinateSpaceArray const & in_spaces);
25051 
25056  LineKey & SetPointCoordinateSpace(size_t in_count, Line::CoordinateSpace const in_spaces []);
25057 
25061  LineKey & UnsetPointCoordinateSpace(SizeTArray const & in_indices);
25062 
25067  LineKey & UnsetPointCoordinateSpace(size_t in_count, size_t const in_indices[]);
25068 
25071  LineKey & UnsetPointCoordinateSpace();
25072 
25078  bool ShowPointCoordinateSpace(size_t in_count, size_t const in_indices[], LineCoordinateSpaceArray & out_spaces) const;
25079 
25084  bool ShowPointCoordinateSpace(SizeTArray const & in_indices, LineCoordinateSpaceArray & out_spaces) const;
25085 
25089  bool ShowPointCoordinateSpace(LineCoordinateSpaceArray & out_spaces) const;
25090 
25096  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25097 
25102  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25103 
25108  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
25109 
25115  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25116 
25122  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25123 };
25124 
25125 
25126 
25128 class HPS_API MarkerKit : public Kit
25129 {
25130 public:
25132  MarkerKit();
25133 
25136  MarkerKit(MarkerKit const & in_kit);
25137 
25141  MarkerKit(MarkerKit && in_that);
25142 
25146  MarkerKit & operator=(MarkerKit && in_that);
25147 
25148  virtual ~MarkerKit();
25149 
25150  static const HPS::Type staticType = HPS::Type::MarkerKit;
25151  HPS::Type ObjectType() const { return staticType; };
25152 
25155  void Consume(MarkerKit & in_kit);
25156 
25159  void Set(MarkerKit const & in_kit);
25160 
25163  void Show(MarkerKit & out_kit) const;
25164 
25168  MarkerKit & operator=(MarkerKit const & in_kit);
25169 
25172  bool Empty() const;
25173 
25177  bool Equals(MarkerKit const & in_kit) const;
25178 
25182  bool operator==(MarkerKit const & in_kit) const;
25183 
25187  bool operator!=(MarkerKit const & in_kit) const;
25188 
25189 
25196  MarkerKit & SetPriority(int in_priority);
25197 
25200  MarkerKit & UnsetPriority();
25201 
25205  bool ShowPriority(int & out_priority) const;
25206 
25210  MarkerKit & SetPoint(Point const & in_point);
25211 
25212 
25215  MarkerKit & UnsetPoint();
25216 
25219  MarkerKit & UnsetEverything();
25220 
25221 
25225  bool ShowPoint(HPS::Point & out_point) const;
25226 
25232  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25233 
25238  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25239 
25244  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25245 
25249  MarkerKit & UnsetUserData(intptr_t in_index);
25250 
25255  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25256 
25260  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
25261 
25264  MarkerKit & UnsetAllUserData();
25265 
25267  size_t ShowUserDataCount() const;
25268 
25272  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25273 
25278  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25279 
25284  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25285 };
25286 
25288 class HPS_API MarkerKey : public GeometryKey
25289 {
25290 public:
25292  MarkerKey();
25293 
25297  explicit MarkerKey(Key const & in_that);
25298 
25301  MarkerKey(MarkerKey const & in_that);
25302 
25306  MarkerKey & operator=(MarkerKey const & in_that);
25307 
25311  MarkerKey(MarkerKey && in_that);
25312 
25316  MarkerKey & operator=(MarkerKey && in_that);
25317 
25318  ~MarkerKey();
25319 
25320  static const HPS::Type staticType = HPS::Type::MarkerKey;
25321  HPS::Type ObjectType() const { return staticType; };
25322 
25323 
25326  void Consume(MarkerKit & in_kit);
25327 
25330  void Set(MarkerKit const & in_kit);
25331 
25334  void Show(MarkerKit & out_kit) const;
25335 
25336 
25340  MarkerKey & SetPoint(Point const & in_point);
25341 
25345  bool ShowPoint(Point & out_point) const;
25346 };
25347 
25348 
25349 
25351 class HPS_API DistantLightKit : public Kit
25352 {
25353 public:
25355  DistantLightKit();
25356 
25359  DistantLightKit(DistantLightKit const & in_kit);
25360 
25364  DistantLightKit(DistantLightKit && in_that);
25365 
25369  DistantLightKit & operator=(DistantLightKit && in_that);
25370 
25371  virtual ~DistantLightKit();
25372 
25373  static const HPS::Type staticType = HPS::Type::DistantLightKit;
25374  HPS::Type ObjectType() const { return staticType; };
25375 
25378  void Consume(DistantLightKit & in_kit);
25379 
25382  void Set(DistantLightKit const & in_kit);
25383 
25386  void Show(DistantLightKit & out_kit) const;
25387 
25391  DistantLightKit & operator=(DistantLightKit const & in_kit);
25392 
25395  bool Empty() const;
25396 
25400  bool Equals(DistantLightKit const & in_kit) const;
25401 
25405  bool operator==(DistantLightKit const & in_kit) const;
25406 
25410  bool operator!=(DistantLightKit const & in_kit) const;
25411 
25412 
25419  DistantLightKit & SetPriority(int in_priority);
25420 
25426  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
25427 
25431  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
25432 
25436  DistantLightKit & SetColorByIndex(float in_index);
25437 
25443  DistantLightKit & SetCameraRelative(bool in_state);
25444 
25445 
25448  DistantLightKit & UnsetPriority();
25449 
25452  DistantLightKit & UnsetDirection();
25453 
25456  DistantLightKit & UnsetColor();
25457 
25460  DistantLightKit & UnsetCameraRelative();
25461 
25464  DistantLightKit & UnsetEverything();
25465 
25466 
25470  bool ShowPriority(int & out_priority) const;
25471 
25475  bool ShowDirection(HPS::Vector & out_vector) const;
25476 
25482  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25483 
25487  bool ShowCameraRelative(bool & out_state) const;
25488 
25494  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25495 
25500  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25501 
25506  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25507 
25511  DistantLightKit & UnsetUserData(intptr_t in_index);
25512 
25517  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25518 
25522  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
25523 
25526  DistantLightKit & UnsetAllUserData();
25527 
25529  size_t ShowUserDataCount() const;
25530 
25534  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25535 
25540  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25541 
25546  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25547 };
25548 
25549 
25550 
25552 class HPS_API DistantLightKey : public GeometryKey
25553 {
25554 public:
25556  DistantLightKey();
25557 
25561  explicit DistantLightKey(Key const & in_that);
25562 
25565  DistantLightKey(DistantLightKey const & in_that);
25566 
25570  DistantLightKey & operator=(DistantLightKey const & in_that);
25571 
25575  DistantLightKey(DistantLightKey && in_that);
25576 
25580  DistantLightKey & operator=(DistantLightKey && in_that);
25581 
25582  ~DistantLightKey();
25583 
25584  static const HPS::Type staticType = HPS::Type::DistantLightKey;
25585  HPS::Type ObjectType() const { return staticType; };
25586 
25589  void Consume(DistantLightKit & in_kit);
25590 
25593  void Set(DistantLightKit const & in_kit);
25594 
25597  void Show(DistantLightKit & out_kit) const;
25598 
25603  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
25604 
25608  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
25609 
25613  DistantLightKey & SetColorByIndex(float in_index);
25614 
25619  DistantLightKey & SetCameraRelative(bool in_state);
25620 
25621 
25624  DistantLightKey & UnsetColor();
25625 
25626 
25630  bool ShowDirection(HPS::Vector & out_vector) const;
25631 
25637  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
25638 
25642  bool ShowCameraRelative(bool & out_state) const;
25643 };
25644 
25645 
25646 
25647 
25649 class HPS_API CylinderKit : public Kit
25650 {
25651 public:
25653  CylinderKit();
25654 
25657  CylinderKit(CylinderKit const & in_kit);
25658 
25662  CylinderKit(CylinderKit && in_that);
25663 
25667  CylinderKit & operator=(CylinderKit && in_that);
25668 
25669  virtual ~CylinderKit();
25670 
25671  static const HPS::Type staticType = HPS::Type::CylinderKit;
25672  HPS::Type ObjectType() const { return staticType; };
25673 
25676  void Consume(CylinderKit & in_kit);
25677 
25680  void Set(CylinderKit const & in_kit);
25681 
25684  void Show(CylinderKit & out_kit) const;
25685 
25689  CylinderKit & operator=(CylinderKit const & in_kit);
25690 
25693  bool Empty() const;
25694 
25698  bool Equals(CylinderKit const & in_kit) const;
25699 
25703  bool operator==(CylinderKit const & in_kit) const;
25704 
25708  bool operator!=(CylinderKit const & in_kit) const;
25709 
25712  size_t GetPointCount() const;
25713 
25720  CylinderKit & SetPriority(int in_priority);
25721 
25724  CylinderKit & UnsetPriority();
25725 
25729  bool ShowPriority(int & out_priority) const;
25730 
25731 
25735  CylinderKit & SetPoints(PointArray const & in_points);
25736 
25741  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
25742 
25746  CylinderKit & SetRadii(FloatArray const & in_radii);
25747 
25752  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
25753 
25757  CylinderKit & SetCaps(Cylinder::Capping in_capping);
25758 
25759 
25762  CylinderKit & UnsetPoints();
25763 
25766  CylinderKit & UnsetRadii();
25767 
25770  CylinderKit & UnsetCaps();
25771 
25774  CylinderKit & UnsetEverything();
25775 
25776 
25780  bool ShowPoints(PointArray & out_points) const;
25781 
25787  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
25788 
25793  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
25794 
25800  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
25801 
25805  bool ShowRadii(FloatArray & out_radii) const;
25806 
25810  bool ShowCaps(Cylinder::Capping & out_caps) const;
25811 
25812 
25819  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25820 
25826  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25827 
25834  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25835 
25842  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25843 
25850  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25851 
25858  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25859 
25865  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25866 
25867 
25874  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25875 
25881  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25882 
25889  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25890 
25897  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25898 
25905  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25906 
25913  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25914 
25920  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
25921 
25922 
25925  CylinderKit & UnsetVertexColors();
25926 
25931  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
25932 
25936  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
25937 
25938 
25942  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
25943 
25949  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
25950 
25955  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
25956 
25961  CylinderKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
25962 
25968  CylinderKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Cylinder::Component in_apply_to);
25969 
25979  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
25980 
25992  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
25993 
26006  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
26007 
26013  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26014 
26019  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26020 
26025  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26026 
26030  CylinderKit & UnsetUserData(intptr_t in_index);
26031 
26036  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26037 
26041  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
26042 
26045  CylinderKit & UnsetAllUserData();
26046 
26048  size_t ShowUserDataCount() const;
26049 
26053  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26054 
26059  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26060 
26065  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26066 };
26067 
26068 
26069 
26071 class HPS_API CylinderKey : public GeometryKey
26072 {
26073 public:
26075  CylinderKey();
26076 
26080  explicit CylinderKey(Key const & in_that);
26081 
26084  CylinderKey(CylinderKey const & in_that);
26085 
26089  CylinderKey & operator=(CylinderKey const & in_that);
26090 
26094  CylinderKey(CylinderKey && in_that);
26095 
26099  CylinderKey & operator=(CylinderKey && in_that);
26100 
26101  ~CylinderKey();
26102 
26103  static const HPS::Type staticType = HPS::Type::CylinderKey;
26104  HPS::Type ObjectType() const { return staticType; };
26105 
26108  void Consume(CylinderKit & in_kit);
26109 
26112  void Set(CylinderKit const & in_kit);
26113 
26114 
26120  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
26121 
26126  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
26127 
26132  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
26133 
26139  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
26140 
26146  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
26147 
26148 
26154  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
26155 
26160  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
26161 
26166  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
26167 
26173  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
26174 
26180  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
26181 
26182 
26185  void Show(CylinderKit & out_kit) const;
26186 
26189  size_t GetPointCount() const;
26190 
26194  bool ShowPoints(PointArray & out_points) const;
26195 
26201  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
26202 
26207  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
26208 
26214  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
26215 
26219  bool ShowRadii(FloatArray & out_radii) const;
26220 
26224  bool ShowCaps(Cylinder::Capping & out_caps) const;
26225 
26226 
26233  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26234 
26241  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26242 
26249  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26250 
26251 
26258  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26259 
26266  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26267 
26274  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26275 
26282  CylinderKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26283 
26289  CylinderKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26290 
26297  CylinderKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26298 
26304  CylinderKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26305 
26312  CylinderKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26313 
26319  CylinderKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26320 
26327  CylinderKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26328 
26334  CylinderKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
26335 
26338  CylinderKey & UnsetVertexColors();
26339 
26344  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
26345 
26349  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
26350 
26356  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
26357 
26362  CylinderKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
26363 
26367  CylinderKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
26368 
26374  CylinderKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Cylinder::Component in_apply_to);
26375 
26381  CylinderKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
26382 
26392  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
26393 
26405  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
26406 
26419  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
26420 };
26421 
26422 
26423 
26424 
26426 class HPS_API SphereKit : public Kit
26427 {
26428 public:
26430  SphereKit();
26431 
26434  SphereKit(SphereKit const & in_kit);
26435 
26439  SphereKit(SphereKit && in_that);
26440 
26444  SphereKit & operator=(SphereKit && in_that);
26445 
26446  virtual ~SphereKit();
26447 
26448  static const HPS::Type staticType = HPS::Type::SphereKit;
26449  HPS::Type ObjectType() const { return staticType; };
26450 
26453  void Consume(SphereKit & in_kit);
26454 
26457  void Set(SphereKit const & in_kit);
26458 
26461  void Show(SphereKit & out_kit) const;
26462 
26466  SphereKit & operator=(SphereKit const & in_kit);
26467 
26470  bool Empty() const;
26471 
26475  bool Equals(SphereKit const & in_kit) const;
26476 
26480  bool operator==(SphereKit const & in_kit) const;
26481 
26485  bool operator!=(SphereKit const & in_kit) const;
26486 
26493  SphereKit & SetPriority(int in_priority);
26494 
26497  SphereKit & UnsetPriority();
26498 
26502  bool ShowPriority(int & out_priority) const;
26503 
26507  SphereKit & SetCenter(Point const & in_center);
26508 
26512  SphereKit & SetRadius(float in_radius);
26513 
26518  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
26519 
26520 
26523  SphereKit & UnsetCenter();
26524 
26527  SphereKit & UnsetRadius();
26528 
26531  SphereKit & UnsetBasis();
26532 
26535  SphereKit & UnsetEverything();
26536 
26537 
26541  bool ShowCenter(Point & out_center) const;
26542 
26546  bool ShowRadius(float & out_radius) const;
26547 
26552  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
26553 
26559  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26560 
26565  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26566 
26571  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26572 
26576  SphereKit & UnsetUserData(intptr_t in_index);
26577 
26582  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26583 
26587  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
26588 
26591  SphereKit & UnsetAllUserData();
26592 
26594  size_t ShowUserDataCount() const;
26595 
26599  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26600 
26605  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26606 
26611  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26612 };
26613 
26615 class HPS_API SphereKey : public GeometryKey
26616 {
26617 public:
26619  SphereKey();
26620 
26624  explicit SphereKey(Key const & in_that);
26625 
26628  SphereKey(SphereKey const & in_that);
26629 
26633  SphereKey & operator=(SphereKey const & in_that);
26634 
26638  SphereKey(SphereKey && in_that);
26639 
26643  SphereKey & operator=(SphereKey && in_that);
26644 
26645  ~SphereKey();
26646 
26647  static const HPS::Type staticType = HPS::Type::SphereKey;
26648  HPS::Type ObjectType() const {return staticType;};
26649 
26652  void Consume(SphereKit & in_kit);
26653 
26656  void Set(SphereKit const & in_kit);
26657 
26660  void Show(SphereKit & out_kit) const;
26661 
26662 
26666  SphereKey & SetCenter(Point const & in_center);
26667 
26671  SphereKey & SetRadius(float in_radius);
26672 
26677  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
26678 
26679 
26683  bool ShowCenter(Point & out_center) const;
26684 
26688  bool ShowRadius(float & out_radius) const;
26689 
26694  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
26695 };
26696 
26697 
26698 
26699 
26701 class HPS_API CircleKit : public Kit
26702 {
26703 public:
26705  CircleKit();
26706 
26709  CircleKit(CircleKit const & in_kit);
26710 
26714  CircleKit(CircleKit && in_that);
26715 
26719  CircleKit & operator=(CircleKit && in_that);
26720 
26721  virtual ~CircleKit();
26722 
26723  static const HPS::Type staticType = HPS::Type::CircleKit;
26724  HPS::Type ObjectType() const { return staticType; };
26725 
26728  void Consume(CircleKit & in_kit);
26729 
26732  void Set(CircleKit const & in_kit);
26733 
26736  void Show(CircleKit & out_kit) const;
26737 
26741  CircleKit & operator=(CircleKit const & in_kit);
26742 
26745  bool Empty() const;
26746 
26750  bool Equals(CircleKit const & in_kit) const;
26751 
26755  bool operator==(CircleKit const & in_kit) const;
26756 
26760  bool operator!=(CircleKit const & in_kit) const;
26761 
26768  CircleKit & SetPriority(int const in_priority);
26769 
26772  CircleKit & UnsetPriority();
26773 
26777  bool ShowPriority(int & out_priority) const;
26778 
26779 
26780 
26784  CircleKit & SetCenter(Point const & in_center);
26785 
26789  CircleKit & SetRadius(float in_radius);
26790 
26794  CircleKit & SetNormal(Vector const & in_normal);
26795 
26796 
26799  CircleKit & UnsetCenter();
26800 
26803  CircleKit & UnsetRadius();
26804 
26807  CircleKit & UnsetNormal();
26808 
26811  CircleKit & UnsetEverything();
26812 
26813 
26817  bool ShowCenter(Point & out_center) const;
26818 
26822  bool ShowRadius(float & out_radius) const;
26823 
26827  bool ShowNormal(Vector & out_normal) const;
26828 
26834  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26835 
26840  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26841 
26846  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26847 
26851  CircleKit & UnsetUserData(intptr_t in_index);
26852 
26857  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26858 
26862  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
26863 
26866  CircleKit & UnsetAllUserData();
26867 
26869  size_t ShowUserDataCount() const;
26870 
26874  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26875 
26880  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26881 
26886  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26887 };
26888 
26889 
26892 class HPS_API CircleKey : public GeometryKey
26893 {
26894 public:
26896  CircleKey();
26897 
26901  explicit CircleKey(Key const & in_that);
26902 
26905  CircleKey(CircleKey const & in_that);
26906 
26910  CircleKey & operator=(CircleKey const & in_that);
26911 
26915  CircleKey(CircleKey && in_that);
26916 
26920  CircleKey & operator=(CircleKey && in_that);
26921 
26922  ~CircleKey();
26923 
26924  static const HPS::Type staticType = HPS::Type::CircleKey;
26925  HPS::Type ObjectType() const { return staticType; };
26926 
26927 
26930  void Consume(CircleKit & in_kit);
26931 
26934  void Set(CircleKit const & in_kit);
26935 
26938  void Show(CircleKit & out_kit) const;
26939 
26940 
26944  CircleKey & SetCenter(Point const & in_center);
26945 
26949  CircleKey & SetRadius(float in_radius);
26950 
26954  CircleKey & SetNormal(Vector const & in_normal);
26955 
26956 
26960  bool ShowCenter(Point & out_center) const;
26961 
26965  bool ShowRadius(float & out_radius) const;
26966 
26970  bool ShowNormal(Vector & out_normal) const;
26971 };
26972 
26973 
26974 
26975 
26977 class HPS_API CircularArcKit : public Kit
26978 {
26979 public:
26981  CircularArcKit();
26982 
26985  CircularArcKit(CircularArcKit const & in_kit);
26986 
26990  CircularArcKit(CircularArcKit && in_that);
26991 
26995  CircularArcKit & operator=(CircularArcKit && in_that);
26996 
26997  virtual ~CircularArcKit();
26998 
26999  static const HPS::Type staticType = HPS::Type::CircularArcKit;
27000  HPS::Type ObjectType() const { return staticType; };
27001 
27004  void Consume(CircularArcKit & in_kit);
27005 
27008  void Set(CircularArcKit const & in_kit);
27009 
27012  void Show(CircularArcKit & out_kit) const;
27013 
27017  CircularArcKit & operator=(CircularArcKit const & in_kit);
27018 
27021  bool Empty() const;
27022 
27026  bool Equals(CircularArcKit const & in_kit) const;
27027 
27031  bool operator==(CircularArcKit const & in_kit) const;
27032 
27036  bool operator!=(CircularArcKit const & in_kit) const;
27037 
27044  CircularArcKit & SetPriority(int in_priority);
27045 
27048  CircularArcKit & UnsetPriority();
27049 
27053  bool ShowPriority(int & out_priority) const;
27054 
27055 
27059  CircularArcKit & SetStart(Point const & in_start);
27060 
27064  CircularArcKit & SetMiddle(Point const & in_middle);
27065 
27069  CircularArcKit & SetEnd(Point const & in_end);
27070 
27071 
27074  CircularArcKit & UnsetStart();
27075 
27078  CircularArcKit & UnsetMiddle();
27079 
27082  CircularArcKit & UnsetEnd();
27083 
27086  CircularArcKit & UnsetEverything();
27087 
27088 
27092  bool ShowStart(Point & out_start) const;
27093 
27097  bool ShowMiddle(Point & out_middle) const;
27098 
27102  bool ShowEnd(Point & out_end) const;
27103 
27109  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27110 
27115  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27116 
27121  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27122 
27126  CircularArcKit & UnsetUserData(intptr_t in_index);
27127 
27132  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27133 
27137  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
27138 
27141  CircularArcKit & UnsetAllUserData();
27142 
27144  size_t ShowUserDataCount() const;
27145 
27149  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27150 
27155  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27156 
27161  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27162 };
27163 
27166 class HPS_API CircularArcKey : public GeometryKey
27167 {
27168 public:
27170  CircularArcKey();
27171 
27175  explicit CircularArcKey(Key const & in_that);
27176 
27179  CircularArcKey(CircularArcKey const & in_that);
27180 
27184  CircularArcKey & operator=(CircularArcKey const & in_that);
27185 
27189  CircularArcKey(CircularArcKey && in_that);
27190 
27194  CircularArcKey & operator=(CircularArcKey && in_that);
27195 
27196  ~CircularArcKey();
27197 
27198  static const HPS::Type staticType = HPS::Type::CircularArcKey;
27199  HPS::Type ObjectType() const { return staticType; };
27200 
27201 
27204  void Consume(CircularArcKit & in_kit);
27205 
27208  void Set(CircularArcKit const & in_kit);
27209 
27212  void Show(CircularArcKit & out_kit) const;
27213 
27214 
27218  CircularArcKey & SetStart(Point const & in_start);
27219 
27223  CircularArcKey & SetMiddle(Point const & in_middle);
27224 
27228  CircularArcKey & SetEnd(Point const & in_end);
27229 
27230 
27234  bool ShowStart(Point & out_start) const;
27235 
27239  bool ShowMiddle(Point & out_middle) const;
27240 
27244  bool ShowEnd(Point & out_end) const;
27245 };
27246 
27247 
27248 
27250 class HPS_API CircularWedgeKit : public Kit
27251 {
27252 public:
27254  CircularWedgeKit();
27255 
27258  CircularWedgeKit(CircularWedgeKit const & in_kit);
27259 
27263  CircularWedgeKit(CircularWedgeKit && in_that);
27264 
27268  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
27269 
27270  virtual ~CircularWedgeKit();
27271 
27272  static const HPS::Type staticType = HPS::Type::CircularWedgeKit;
27273  HPS::Type ObjectType() const { return staticType; };
27274 
27277  void Consume(CircularWedgeKit & in_kit);
27278 
27281  void Set(CircularWedgeKit const & in_kit);
27282 
27285  void Show(CircularWedgeKit & out_kit) const;
27286 
27290  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
27291 
27294  bool Empty() const;
27295 
27299  bool Equals(CircularWedgeKit const & in_kit) const;
27300 
27304  bool operator==(CircularWedgeKit const & in_kit) const;
27305 
27309  bool operator!=(CircularWedgeKit const & in_kit) const;
27310 
27311 
27318  CircularWedgeKit & SetPriority(int in_priority);
27319 
27322  CircularWedgeKit & UnsetPriority();
27323 
27327  bool ShowPriority(int & out_priority) const;
27328 
27329 
27333  CircularWedgeKit & SetStart(Point const & in_start);
27334 
27338  CircularWedgeKit & SetMiddle(Point const & in_middle);
27339 
27343  CircularWedgeKit & SetEnd(Point const & in_end);
27344 
27345 
27348  CircularWedgeKit & UnsetStart();
27349 
27352  CircularWedgeKit & UnsetMiddle();
27353 
27356  CircularWedgeKit & UnsetEnd();
27357 
27360  CircularWedgeKit & UnsetEverything();
27361 
27362 
27366  bool ShowStart(Point & out_start) const;
27367 
27371  bool ShowMiddle(Point & out_middle) const;
27372 
27376  bool ShowEnd(Point & out_end) const;
27377 
27383  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27384 
27389  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27390 
27395  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27396 
27400  CircularWedgeKit & UnsetUserData(intptr_t in_index);
27401 
27406  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27407 
27411  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
27412 
27415  CircularWedgeKit & UnsetAllUserData();
27416 
27418  size_t ShowUserDataCount() const;
27419 
27423  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27424 
27429  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27430 
27435  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27436 };
27437 
27438 
27442 class HPS_API CircularWedgeKey : public GeometryKey
27443 {
27444 public:
27446  CircularWedgeKey();
27447 
27451  explicit CircularWedgeKey(Key const & in_that);
27452 
27455  CircularWedgeKey(CircularWedgeKey const & in_that);
27456 
27460  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
27461 
27465  CircularWedgeKey(CircularWedgeKey && in_that);
27466 
27470  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
27471 
27472  ~CircularWedgeKey();
27473 
27474  static const HPS::Type staticType = HPS::Type::CircularWedgeKey;
27475  HPS::Type ObjectType() const { return staticType; };
27476 
27477 
27480  void Consume(CircularWedgeKit & in_kit);
27481 
27484  void Set(CircularWedgeKit const & in_kit);
27485 
27488  void Show(CircularWedgeKit & out_kit) const;
27489 
27490 
27494  CircularWedgeKey & SetStart(Point const & in_start);
27495 
27499  CircularWedgeKey & SetMiddle(Point const & in_middle);
27500 
27504  CircularWedgeKey & SetEnd(Point const & in_end);
27505 
27506 
27510  bool ShowStart(Point & out_start) const;
27511 
27515  bool ShowMiddle(Point & out_middle) const;
27516 
27520  bool ShowEnd(Point & out_end) const;
27521 };
27522 
27523 
27524 
27526 class HPS_API CuttingSectionKit : public Kit
27527 {
27528 public:
27531 
27534  CuttingSectionKit(CuttingSectionKit const & in_kit);
27535 
27540 
27544  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
27545 
27546  virtual ~CuttingSectionKit();
27547 
27548  static const HPS::Type staticType = HPS::Type::CuttingSectionKit;
27549  HPS::Type ObjectType() const { return staticType; };
27550 
27553  void Consume(CuttingSectionKit & in_kit);
27554 
27557  void Set(CuttingSectionKit const & in_kit);
27558 
27561  void Show(CuttingSectionKit & out_kit) const;
27562 
27566  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
27567 
27570  bool Empty() const;
27571 
27575  bool Equals(CuttingSectionKit const & in_kit) const;
27576 
27580  bool operator==(CuttingSectionKit const & in_kit) const;
27581 
27585  bool operator!=(CuttingSectionKit const & in_kit) const;
27586 
27593  CuttingSectionKit & SetPriority(int in_priority);
27594 
27597  CuttingSectionKit & UnsetPriority();
27598 
27602  bool ShowPriority(int & out_priority) const;
27603 
27604 
27608  CuttingSectionKit & SetPlanes(Plane const & in_plane);
27609 
27613  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
27614 
27619  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
27620 
27626  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
27627 
27628 
27631  CuttingSectionKit & UnsetPlanes();
27632 
27635  CuttingSectionKit & UnsetVisualization();
27636 
27639  CuttingSectionKit & UnsetEverything();
27640 
27641 
27644  size_t GetPlaneCount() const;
27645 
27649  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
27650 
27656  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
27657 
27658 
27665  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
27666 
27672  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
27673 
27680  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
27681 
27688  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
27689 
27697  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
27698 
27704  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27705 
27710  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27711 
27716  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27717 
27721  CuttingSectionKit & UnsetUserData(intptr_t in_index);
27722 
27727  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27728 
27732  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
27733 
27736  CuttingSectionKit & UnsetAllUserData();
27737 
27739  size_t ShowUserDataCount() const;
27740 
27744  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27745 
27750  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27751 
27756  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27757 };
27758 
27759 
27761 class HPS_API CuttingSectionKey : public GeometryKey
27762 {
27763 public:
27766 
27770  explicit CuttingSectionKey(Key const & in_that);
27771 
27774  CuttingSectionKey(CuttingSectionKey const & in_that);
27775 
27779  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
27780 
27785 
27789  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
27790 
27791  ~CuttingSectionKey();
27792 
27793  static const HPS::Type staticType = HPS::Type::CuttingSectionKey;
27794  HPS::Type ObjectType() const { return staticType; };
27795 
27796 
27799  void Consume(CuttingSectionKit & in_kit);
27800 
27803  void Set(CuttingSectionKit const & in_kit);
27804 
27807  void Show(CuttingSectionKit & out_kit) const;
27808 
27809 
27813  CuttingSectionKey & SetPlanes(Plane const & in_plane);
27814 
27818  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
27819 
27824  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
27825 
27831  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
27832 
27833 
27836  size_t GetPlaneCount() const;
27837 
27841  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
27842 
27848  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
27849 
27850 
27857  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
27858 
27864  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
27865 
27872  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
27873 
27880  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
27881 
27887  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
27888 };
27889 
27890 
27891 
27893 class HPS_API InfiniteLineKit : public Kit
27894 {
27895 public:
27897  InfiniteLineKit();
27898 
27901  InfiniteLineKit(InfiniteLineKit const & in_kit);
27902 
27906  InfiniteLineKit(InfiniteLineKit && in_that);
27907 
27911  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
27912 
27913  virtual ~InfiniteLineKit();
27914 
27915  static const HPS::Type staticType = HPS::Type::InfiniteLineKit;
27916  HPS::Type ObjectType() const { return staticType; };
27917 
27920  void Consume(InfiniteLineKit & in_kit);
27921 
27924  void Set(InfiniteLineKit const & in_kit);
27925 
27928  void Show(InfiniteLineKit & out_kit) const;
27929 
27933  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
27934 
27937  bool Empty() const;
27938 
27942  bool Equals(InfiniteLineKit const & in_kit) const;
27943 
27947  bool operator==(InfiniteLineKit const & in_kit) const;
27948 
27952  bool operator!=(InfiniteLineKit const & in_kit) const;
27953 
27960  InfiniteLineKit & SetPriority(int in_priority);
27961 
27964  InfiniteLineKit & UnsetPriority();
27965 
27969  bool ShowPriority(int & out_priority) const;
27970 
27971 
27975  InfiniteLineKit & SetFirst(Point const & in_first);
27976 
27980  InfiniteLineKit & SetSecond(Point const & in_second);
27981 
27985  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
27986 
27987 
27990  InfiniteLineKit & UnsetFirst();
27991 
27994  InfiniteLineKit & UnsetSecond();
27995 
27998  InfiniteLineKit & UnsetType();
27999 
28002  InfiniteLineKit & UnsetEverything();
28003 
28004 
28008  bool ShowFirst(Point & out_first) const;
28009 
28013  bool ShowSecond(Point & out_second) const;
28014 
28018  bool ShowType(InfiniteLine::Type & out_type) const;
28019 
28025  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28026 
28031  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28032 
28037  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28038 
28042  InfiniteLineKit & UnsetUserData(intptr_t in_index);
28043 
28048  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28049 
28053  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
28054 
28057  InfiniteLineKit & UnsetAllUserData();
28058 
28060  size_t ShowUserDataCount() const;
28061 
28065  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28066 
28071  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28072 
28077  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28078 };
28079 
28080 
28082 class HPS_API InfiniteLineKey : public GeometryKey
28083 {
28084 public:
28086  InfiniteLineKey();
28087 
28091  explicit InfiniteLineKey(Key const & in_that);
28092 
28095  InfiniteLineKey(InfiniteLineKey const & in_that);
28096 
28100  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
28101 
28105  InfiniteLineKey(InfiniteLineKey && in_that);
28106 
28110  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
28111 
28112  ~InfiniteLineKey();
28113 
28114  static const HPS::Type staticType = HPS::Type::InfiniteLineKey;
28115  HPS::Type ObjectType() const { return staticType; };
28116 
28119  void Consume(InfiniteLineKit & in_kit);
28120 
28123  void Set(InfiniteLineKit const & in_kit);
28124 
28127  void Show(InfiniteLineKit & out_kit) const;
28128 
28129 
28133  InfiniteLineKey & SetFirst(Point const & in_first);
28134 
28138  InfiniteLineKey & SetSecond(Point const & in_second);
28139 
28143  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
28144 
28145 
28149  bool ShowFirst(Point & out_first) const;
28150 
28154  bool ShowSecond(Point & out_second) const;
28155 
28159  bool ShowType(InfiniteLine::Type & out_type) const;
28160 };
28161 
28162 
28163 
28167 class HPS_API SpotlightKit : public Kit
28168 {
28169 public:
28171  SpotlightKit();
28172 
28175  SpotlightKit(SpotlightKit const & in_kit);
28176 
28180  SpotlightKit(SpotlightKit && in_that);
28181 
28185  SpotlightKit & operator=(SpotlightKit && in_that);
28186 
28187  virtual ~SpotlightKit();
28188 
28189  static const HPS::Type staticType = HPS::Type::SpotlightKit;
28190  HPS::Type ObjectType() const { return staticType; };
28191 
28195  static SpotlightKit GetDefault();
28196 
28199  void Consume(SpotlightKit & in_kit);
28200 
28203  void Set(SpotlightKit const & in_kit);
28204 
28207  void Show(SpotlightKit & out_kit) const;
28208 
28212  SpotlightKit & operator=(SpotlightKit const & in_kit);
28213 
28216  bool Empty() const;
28217 
28221  bool Equals(SpotlightKit const & in_kit) const;
28222 
28226  bool operator==(SpotlightKit const & in_kit) const;
28227 
28231  bool operator!=(SpotlightKit const & in_kit) const;
28232 
28233 
28240  SpotlightKit & SetPriority(int in_priority);
28241 
28247  SpotlightKit & SetPosition(HPS::Point const & in_position);
28248 
28254  SpotlightKit & SetTarget(HPS::Point const & in_target);
28255 
28259  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
28260 
28264  SpotlightKit & SetColorByIndex(float in_index);
28265 
28272 
28279 
28285  SpotlightKit & SetConcentration(float in_concentration);
28286 
28292  SpotlightKit & SetCameraRelative(bool in_state);
28293 
28294 
28297  SpotlightKit & UnsetPriority();
28298 
28301  SpotlightKit & UnsetPosition();
28302 
28305  SpotlightKit & UnsetTarget();
28306 
28309  SpotlightKit & UnsetColor();
28310 
28313  SpotlightKit & UnsetOuterCone();
28314 
28317  SpotlightKit & UnsetInnerCone();
28318 
28321  SpotlightKit & UnsetConcentration();
28322 
28325  SpotlightKit & UnsetCameraRelative();
28326 
28329  SpotlightKit & UnsetEverything();
28330 
28331 
28335  bool ShowPriority(int & out_priority) const;
28336 
28340  bool ShowPosition(HPS::Point & out_position) const;
28341 
28345  bool ShowTarget(HPS::Point & out_target) const;
28346 
28352  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28353 
28358  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
28359 
28364  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
28365 
28369  bool ShowConcentration(float & out_concentration) const;
28370 
28374  bool ShowCameraRelative(bool & out_state) const;
28375 
28381  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28382 
28387  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28388 
28393  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28394 
28398  SpotlightKit & UnsetUserData(intptr_t in_index);
28399 
28404  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28405 
28409  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
28410 
28413  SpotlightKit & UnsetAllUserData();
28414 
28416  size_t ShowUserDataCount() const;
28417 
28421  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28422 
28427  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28428 
28433  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28434 };
28435 
28436 
28438 class HPS_API SpotlightKey : public GeometryKey
28439 {
28440 public:
28442  SpotlightKey();
28443 
28447  explicit SpotlightKey(Key const & in_that);
28448 
28451  SpotlightKey(SpotlightKey const & in_that);
28452 
28456  SpotlightKey & operator=(SpotlightKey const & in_that);
28457 
28461  SpotlightKey(SpotlightKey && in_that);
28462 
28466  SpotlightKey & operator=(SpotlightKey && in_that);
28467 
28468  ~SpotlightKey();
28469 
28470  static const HPS::Type staticType = HPS::Type::SpotlightKey;
28471  HPS::Type ObjectType() const { return staticType; };
28472 
28475  void Consume(SpotlightKit & in_kit);
28476 
28479  void Set(SpotlightKit const & in_kit);
28480 
28483  void Show(SpotlightKit & out_kit) const;
28484 
28485 
28491  SpotlightKey & SetPosition(HPS::Point const & in_position);
28492 
28498  SpotlightKey & SetTarget(HPS::Point const & in_target);
28499 
28503  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
28504 
28508  SpotlightKey & SetColorByIndex(float in_index);
28509 
28516 
28523 
28529  SpotlightKey & SetConcentration(float in_concentration);
28530 
28536  SpotlightKey & SetCameraRelative(bool in_state);
28537 
28538 
28541  SpotlightKey & UnsetColor();
28542 
28543 
28547  bool ShowPosition(HPS::Point & out_position) const;
28548 
28552  bool ShowTarget(HPS::Point & out_target) const;
28553 
28559  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
28560 
28565  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
28566 
28571  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
28572 
28576  bool ShowConcentration(float & out_concentration) const;
28577 
28581  bool ShowCameraRelative(bool & out_state) const;
28582 };
28583 
28584 
28585 
28587 class HPS_API NURBSCurveKit : public Kit
28588 {
28589 public:
28591  NURBSCurveKit();
28592 
28595  NURBSCurveKit(NURBSCurveKit const & in_kit);
28596 
28600  NURBSCurveKit(NURBSCurveKit && in_that);
28601 
28605  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
28606 
28607  virtual ~NURBSCurveKit();
28608 
28609  static const HPS::Type staticType = HPS::Type::NURBSCurveKit;
28610  HPS::Type ObjectType() const { return staticType; };
28611 
28614  void Consume(NURBSCurveKit & in_kit);
28615 
28618  void Set(NURBSCurveKit const & in_kit);
28619 
28622  void Show(NURBSCurveKit & out_kit) const;
28623 
28627  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
28628 
28631  bool Empty() const;
28632 
28636  bool Equals(NURBSCurveKit const & in_kit) const;
28637 
28641  bool operator==(NURBSCurveKit const & in_kit) const;
28642 
28646  bool operator!=(NURBSCurveKit const & in_kit) const;
28647 
28650  size_t GetPointCount() const;
28651 
28658  NURBSCurveKit & SetPriority(int in_priority);
28659 
28662  NURBSCurveKit & UnsetPriority();
28663 
28667  bool ShowPriority(int & out_priority) const;
28668 
28672  NURBSCurveKit & SetDegree(size_t in_degree);
28673 
28677  NURBSCurveKit & SetPoints(PointArray const & in_points);
28678 
28683  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
28684 
28688  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
28689 
28694  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
28695 
28699  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
28700 
28705  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
28706 
28711  NURBSCurveKit & SetParameters(float in_start, float in_end);
28712 
28713 
28716  NURBSCurveKit & UnsetDegree();
28717 
28720  NURBSCurveKit & UnsetPoints();
28721 
28724  NURBSCurveKit & UnsetWeights();
28725 
28728  NURBSCurveKit & UnsetKnots();
28729 
28732  NURBSCurveKit & UnsetParameters();
28733 
28736  NURBSCurveKit & UnsetEverything();
28737 
28738 
28742  bool ShowDegree(size_t & out_degree) const;
28743 
28747  bool ShowPoints(PointArray & out_points) const;
28748 
28754  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
28755 
28760  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
28761 
28767  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
28768 
28772  bool ShowWeights(FloatArray & out_weights) const;
28773 
28777  bool ShowKnots(FloatArray & out_knots) const;
28778 
28783  bool ShowParameters(float & out_start, float & out_end) const;
28784 
28785 
28792  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
28793 
28799  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
28800 
28807  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
28808 
28815  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
28816 
28823  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
28824 
28825 
28833  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
28834 
28841  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
28842 
28850  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
28851 
28858  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
28859 
28866  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
28867 
28868 
28874  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
28875 
28880  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
28881 
28887  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
28888 
28895  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28896 
28903  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28904 
28910  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28911 
28916  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28917 
28922  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28923 
28927  NURBSCurveKit & UnsetUserData(intptr_t in_index);
28928 
28933  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28934 
28938  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
28939 
28942  NURBSCurveKit & UnsetAllUserData();
28943 
28945  size_t ShowUserDataCount() const;
28946 
28950  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28951 
28956  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28957 
28962  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28963 };
28964 
28965 
28967 class HPS_API NURBSCurveKey : public GeometryKey
28968 {
28969 public:
28971  NURBSCurveKey();
28972 
28976  explicit NURBSCurveKey(Key const & in_that);
28977 
28980  NURBSCurveKey(NURBSCurveKey const & in_that);
28981 
28985  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
28986 
28990  NURBSCurveKey(NURBSCurveKey && in_that);
28991 
28995  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
28996 
28997  ~NURBSCurveKey();
28998 
28999  static const HPS::Type staticType = HPS::Type::NURBSCurveKey;
29000  HPS::Type ObjectType() const {return staticType;};
29001 
29004  void Consume(NURBSCurveKit & in_kit);
29005 
29008  void Set(NURBSCurveKit const & in_kit);
29009 
29012  void Show(NURBSCurveKit & out_kit) const;
29013 
29016  size_t GetPointCount() const;
29017 
29022  NURBSCurveKey & SetParameters(float in_start, float in_end);
29023 
29027  bool ShowDegree(size_t & out_degree) const;
29028 
29032  bool ShowPoints(PointArray & out_points) const;
29033 
29039  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29040 
29045  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29046 
29052  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29053 
29057  bool ShowWeights(FloatArray & out_weights) const;
29058 
29062  bool ShowKnots(FloatArray & out_knots) const;
29063 
29068  bool ShowParameters(float & out_start, float & out_end) const;
29069 
29070 
29078  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29079 
29086  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29087 
29088 
29097  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
29098 
29106  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
29107 
29108 
29116  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29117 
29124  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29125 };
29126 
29127 
29128 
29130 class HPS_API NURBSSurfaceKit : public Kit
29131 {
29132 public:
29134  NURBSSurfaceKit();
29135 
29138  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
29139 
29143  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
29144 
29148  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
29149 
29150  virtual ~NURBSSurfaceKit();
29151 
29152  static const HPS::Type staticType = HPS::Type::NURBSSurfaceKit;
29153  HPS::Type ObjectType() const { return staticType; };
29154 
29157  void Consume(NURBSSurfaceKit & in_kit);
29158 
29161  void Set(NURBSSurfaceKit const & in_kit);
29162 
29165  void Show(NURBSSurfaceKit & out_kit) const;
29166 
29170  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
29171 
29174  bool Empty() const;
29175 
29179  bool Equals(NURBSSurfaceKit const & in_kit) const;
29180 
29184  bool operator==(NURBSSurfaceKit const & in_kit) const;
29185 
29189  bool operator!=(NURBSSurfaceKit const & in_kit) const;
29190 
29193  size_t GetPointCount() const;
29194 
29201  NURBSSurfaceKit & SetPriority(int in_priority);
29202 
29205  NURBSSurfaceKit & UnsetPriority();
29206 
29210  bool ShowPriority(int & out_priority) const;
29211 
29215  NURBSSurfaceKit & SetUDegree(size_t in_degree);
29216 
29220  NURBSSurfaceKit & SetVDegree(size_t in_degree);
29221 
29225  NURBSSurfaceKit & SetUCount(size_t in_count);
29226 
29230  NURBSSurfaceKit & SetVCount(size_t in_count);
29231 
29235  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
29236 
29241  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
29242 
29247  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
29248 
29254  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
29255 
29260  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
29261 
29267  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
29268 
29273  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
29274 
29280  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
29281 
29285  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
29286 
29291  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
29292 
29296  NURBSSurfaceKit & SetTrim(TrimKit const & in_trim);
29297 
29298 
29301  NURBSSurfaceKit & UnsetUDegree();
29302 
29305  NURBSSurfaceKit & UnsetVDegree();
29306 
29309  NURBSSurfaceKit & UnsetUCount();
29310 
29313  NURBSSurfaceKit & UnsetVCount();
29314 
29317  NURBSSurfaceKit & UnsetPoints();
29318 
29321  NURBSSurfaceKit & UnsetWeights();
29322 
29325  NURBSSurfaceKit & UnsetUKnots();
29326 
29329  NURBSSurfaceKit & UnsetVKnots();
29330 
29333  NURBSSurfaceKit & UnsetTrims();
29334 
29337  NURBSSurfaceKit & UnsetEverything();
29338 
29339 
29343  bool ShowUDegree(size_t & out_degree) const;
29344 
29348  bool ShowVDegree(size_t & out_degree) const;
29349 
29353  bool ShowUCount(size_t & out_count) const;
29354 
29358  bool ShowVCount(size_t & out_count) const;
29359 
29363  bool ShowPoints(PointArray & out_points) const;
29364 
29370  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29371 
29376  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29377 
29383  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29384 
29388  bool ShowWeights(FloatArray & out_weights) const;
29389 
29393  bool ShowUKnots(FloatArray & out_knots) const;
29394 
29398  bool ShowVKnots(FloatArray & out_knots) const;
29399 
29403  bool ShowTrims(TrimKitArray & out_trims) const;
29404 
29405 
29412  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
29413 
29419  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
29420 
29427  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
29428 
29435  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29436 
29443  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29444 
29445 
29453  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
29454 
29461  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
29462 
29470  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
29471 
29478  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
29479 
29486  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
29487 
29488 
29495  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
29496 
29502  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
29503 
29510  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
29511 
29518  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29519 
29526  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29527 
29528 
29535  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
29536 
29542  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
29543 
29550  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
29551 
29558  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29559 
29566  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29567 
29573  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29574 
29579  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29580 
29585  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29586 
29590  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
29591 
29596  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29597 
29601  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
29602 
29605  NURBSSurfaceKit & UnsetAllUserData();
29606 
29608  size_t ShowUserDataCount() const;
29609 
29613  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29614 
29619  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29620 
29625  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29626 };
29627 
29628 
29630 class HPS_API NURBSSurfaceKey : public GeometryKey
29631 {
29632 public:
29634  NURBSSurfaceKey();
29635 
29639  explicit NURBSSurfaceKey(Key const & in_that);
29640 
29643  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
29644 
29648  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
29649 
29653  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
29654 
29658  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
29659 
29660  ~NURBSSurfaceKey();
29661 
29662  static const HPS::Type staticType = HPS::Type::NURBSSurfaceKey;
29663  HPS::Type ObjectType() const { return staticType; };
29664 
29667  void Consume(NURBSSurfaceKit & in_kit);
29668 
29671  void Set(NURBSSurfaceKit const & in_kit);
29672 
29675  void Show(NURBSSurfaceKit & out_kit) const;
29676 
29679  size_t GetPointCount() const;
29680 
29685  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
29686 
29690  NURBSSurfaceKey & SetTrim(TrimKit const & in_trim);
29691 
29695  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
29696 
29697 
29700  NURBSSurfaceKey & UnsetTrims();
29701 
29702 
29706  bool ShowUDegree(size_t & out_degree) const;
29707 
29711  bool ShowVDegree(size_t & out_degree) const;
29712 
29716  bool ShowUCount(size_t & out_count) const;
29717 
29721  bool ShowVCount(size_t & out_count) const;
29722 
29726  bool ShowPoints(PointArray & out_points) const;
29727 
29733  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
29734 
29739  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
29740 
29746  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
29747 
29751  bool ShowWeights(FloatArray & out_weights) const;
29752 
29756  bool ShowUKnots(FloatArray & out_knots) const;
29757 
29761  bool ShowVKnots(FloatArray & out_knots) const;
29762 
29766  bool ShowTrims(TrimKitArray & out_trims) const;
29767 
29768 
29776  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29777 
29784  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29785 
29786 
29795  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
29796 
29804  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
29805 
29806 
29814  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29815 
29822  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29823 
29824 
29832  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
29833 
29840  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
29841 };
29842 
29843 
29844 
29846 class HPS_API TrimElement : public Object
29847 {
29848 public:
29850  TrimElement();
29851 
29854  TrimElement(TrimElement const & in_that);
29855 
29859  TrimElement(LineKit const & in_line);
29860 
29864  TrimElement(NURBSCurveKit const & in_curve);
29865 
29869  TrimElement(TrimElement && in_that);
29870 
29874  TrimElement & operator=(TrimElement && in_that);
29875 
29876  ~TrimElement();
29877 
29878  static const HPS::Type staticType = HPS::Type::TrimElement;
29879  HPS::Type ObjectType() const { return staticType; };
29880 
29883  void Set(TrimElement const & in_that);
29884 
29888  TrimElement & operator=(TrimElement const & in_that);
29889 
29893  bool Equals(TrimElement const & in_that) const;
29894 
29898  bool operator==(TrimElement const & in_that) const;
29899 
29903  bool operator!=(TrimElement const & in_that) const;
29904 
29905 
29909  void SetCurve(LineKit const & in_line);
29910 
29914  void SetCurve(NURBSCurveKit const & in_curve);
29915 
29921  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
29922 };
29923 
29924 
29925 
29927 class HPS_API TrimKit : public Kit
29928 {
29929 public:
29931  TrimKit();
29932 
29935  TrimKit(TrimKit const & in_kit);
29936 
29940  TrimKit(TrimKit && in_that);
29941 
29945  TrimKit & operator=(TrimKit && in_that);
29946 
29947  virtual ~TrimKit();
29948 
29949  static const HPS::Type staticType = HPS::Type::TrimKit;
29950  HPS::Type ObjectType() const { return staticType; };
29951 
29954  void Set(TrimKit const & in_kit);
29955 
29958  void Show(TrimKit & out_kit) const;
29959 
29963  TrimKit & operator=(TrimKit const & in_kit);
29964 
29967  bool Empty() const;
29968 
29972  bool Equals(TrimKit const & in_kit) const;
29973 
29977  bool operator==(TrimKit const & in_kit) const;
29978 
29982  bool operator!=(TrimKit const & in_kit) const;
29983 
29984 
29989  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
29990 
29994  TrimKit & SetShape(TrimElementArray const & in_shape);
29995 
29999  TrimKit & SetShape(TrimElement const & in_shape);
30000 
30001 
30005  TrimKit & SetOperation(Trim::Operation in_operation);
30006 
30007 
30010  TrimKit & UnsetShape();
30011 
30014  TrimKit & UnsetOperation();
30015 
30018  TrimKit & UnsetEverything();
30019 
30020 
30024  bool ShowShape(TrimElementArray & out_shape) const;
30025 
30029  bool ShowOperation(Trim::Operation & out_operation) const;
30030 };
30031 
30032 
30033 
30035 class HPS_API EllipseKit : public Kit
30036 {
30037 public:
30039  EllipseKit();
30040 
30043  EllipseKit(EllipseKit const & in_kit);
30044 
30048  EllipseKit(EllipseKit && in_that);
30049 
30053  EllipseKit & operator=(EllipseKit && in_that);
30054 
30055  virtual ~EllipseKit();
30056 
30057  static const HPS::Type staticType = HPS::Type::EllipseKit;
30058  HPS::Type ObjectType() const { return staticType; };
30059 
30062  void Consume(EllipseKit & in_kit);
30063 
30066  void Set(EllipseKit const & in_kit);
30067 
30070  void Show(EllipseKit & out_kit) const;
30071 
30075  EllipseKit & operator=(EllipseKit const & in_kit);
30076 
30079  bool Empty() const;
30080 
30084  bool Equals(EllipseKit const & in_kit) const;
30085 
30089  bool operator==(EllipseKit const & in_kit) const;
30090 
30094  bool operator!=(EllipseKit const & in_kit) const;
30095 
30102  EllipseKit & SetPriority(int in_priority);
30103 
30106  EllipseKit & UnsetPriority();
30107 
30111  bool ShowPriority(int & out_priority) const;
30112 
30113 
30117  EllipseKit & SetCenter(Point const & in_center);
30118 
30122  EllipseKit & SetMajor(Point const & in_major);
30123 
30127  EllipseKit & SetMinor(Point const & in_minor);
30128 
30129 
30132  EllipseKit & UnsetCenter();
30133 
30136  EllipseKit & UnsetMajor();
30137 
30140  EllipseKit & UnsetMinor();
30141 
30144  EllipseKit & UnsetEverything();
30145 
30146 
30150  bool ShowCenter(Point & out_center) const;
30151 
30155  bool ShowMajor(Point & out_major) const;
30156 
30160  bool ShowMinor(Point & out_minor) const;
30161 
30167  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30168 
30173  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30174 
30179  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30180 
30184  EllipseKit & UnsetUserData(intptr_t in_index);
30185 
30190  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30191 
30195  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
30196 
30199  EllipseKit & UnsetAllUserData();
30200 
30202  size_t ShowUserDataCount() const;
30203 
30207  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30208 
30213  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30214 
30219  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30220 };
30221 
30222 
30223 
30225 class HPS_API EllipseKey : public GeometryKey
30226 {
30227 public:
30229  EllipseKey();
30230 
30234  explicit EllipseKey(Key const & in_that);
30235 
30238  EllipseKey(EllipseKey const & in_that);
30239 
30243  EllipseKey & operator=(EllipseKey const & other);
30244 
30248  EllipseKey(EllipseKey && in_that);
30249 
30253  EllipseKey & operator=(EllipseKey && in_that);
30254 
30255  ~EllipseKey();
30256 
30257  static const HPS::Type staticType = HPS::Type::EllipseKey;
30258  HPS::Type ObjectType() const { return staticType; };
30259 
30262  void Consume(EllipseKit & in_kit);
30263 
30266  void Set(EllipseKit const & in_kit);
30267 
30270  void Show(EllipseKit & out_kit) const;
30271 
30272 
30276  EllipseKey & SetCenter(Point const & in_center);
30277 
30281  EllipseKey & SetMajor(Point const & in_major);
30282 
30286  EllipseKey & SetMinor(Point const & in_minor);
30287 
30288 
30292  bool ShowCenter(Point & out_center) const;
30293 
30297  bool ShowMajor(Point & out_major) const;
30298 
30302  bool ShowMinor(Point & out_minor) const;
30303 };
30304 
30305 
30306 
30308 class HPS_API EllipticalArcKit : public Kit
30309 {
30310 public:
30312  EllipticalArcKit();
30313 
30316  EllipticalArcKit(EllipticalArcKit const & in_kit);
30317 
30321  EllipticalArcKit(EllipticalArcKit && in_that);
30322 
30326  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
30327 
30328  virtual ~EllipticalArcKit();
30329 
30330  static const HPS::Type staticType = HPS::Type::EllipticalArcKit;
30331  HPS::Type ObjectType() const { return staticType; };
30332 
30335  void Consume(EllipticalArcKit & in_kit);
30336 
30339  void Set(EllipticalArcKit const & in_kit);
30340 
30343  void Show(EllipticalArcKit & out_kit) const;
30344 
30348  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
30349 
30352  bool Empty() const;
30353 
30357  bool Equals(EllipticalArcKit const & in_kit) const;
30358 
30362  bool operator==(EllipticalArcKit const & in_kit) const;
30363 
30367  bool operator!=(EllipticalArcKit const & in_kit) const;
30368 
30375  EllipticalArcKit & SetPriority(int in_priority);
30376 
30379  EllipticalArcKit & UnsetPriority();
30380 
30384  bool ShowPriority(int & out_priority) const;
30385 
30386 
30390  EllipticalArcKit & SetCenter(Point const & in_center);
30391 
30395  EllipticalArcKit & SetMajor(Point const & in_major);
30396 
30400  EllipticalArcKit & SetMinor(Point const & in_minor);
30401 
30409  EllipticalArcKit & SetStart(float in_start);
30410 
30418  EllipticalArcKit & SetEnd(float in_end);
30419 
30420 
30423  EllipticalArcKit & UnsetCenter();
30424 
30427  EllipticalArcKit & UnsetMajor();
30428 
30431  EllipticalArcKit & UnsetMinor();
30432 
30435  EllipticalArcKit & UnsetStart();
30436 
30439  EllipticalArcKit & UnsetEnd();
30440 
30443  EllipticalArcKit & UnsetEverything();
30444 
30445 
30449  bool ShowCenter(Point & out_center) const;
30450 
30454  bool ShowMajor(Point & out_major) const;
30455 
30459  bool ShowMinor(Point & out_minor) const;
30460 
30464  bool ShowStart(float & out_start) const;
30465 
30469  bool ShowEnd(float & out_end) const;
30470 
30476  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
30477 
30482  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
30483 
30488  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
30489 
30493  EllipticalArcKit & UnsetUserData(intptr_t in_index);
30494 
30499  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
30500 
30504  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
30505 
30508  EllipticalArcKit & UnsetAllUserData();
30509 
30511  size_t ShowUserDataCount() const;
30512 
30516  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
30517 
30522  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
30523 
30528  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
30529 };
30530 
30531 
30533 class HPS_API EllipticalArcKey : public GeometryKey
30534 {
30535 public:
30537  EllipticalArcKey();
30538 
30542  explicit EllipticalArcKey(Key const & in_that);
30543 
30546  EllipticalArcKey(EllipticalArcKey const & in_that);
30547 
30551  EllipticalArcKey & operator=(EllipticalArcKey const & other);
30552 
30556  EllipticalArcKey(EllipticalArcKey && in_that);
30557 
30561  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
30562 
30563  ~EllipticalArcKey();
30564 
30565  static const HPS::Type staticType = HPS::Type::EllipticalArcKey;
30566  HPS::Type ObjectType() const { return staticType; };
30567 
30568 
30571  void Consume(EllipticalArcKit & in_kit);
30572 
30575  void Set(EllipticalArcKit const & in_kit);
30576 
30579  void Show(EllipticalArcKit & out_kit) const;
30580 
30581 
30585  EllipticalArcKey & SetCenter(Point const & in_center);
30586 
30590  EllipticalArcKey & SetMajor(Point const & in_major);
30591 
30595  EllipticalArcKey & SetMinor(Point const & in_minor);
30596 
30604  EllipticalArcKey & SetStart(float in_start);
30605 
30613  EllipticalArcKey & SetEnd(float in_end);
30614 
30615 
30619  bool ShowCenter(Point & out_center) const;
30620 
30624  bool ShowMajor(Point & out_major) const;
30625 
30629  bool ShowMinor(Point & out_minor) const;
30630 
30634  bool ShowStart(float & out_start) const;
30635 
30639  bool ShowEnd(float & out_end) const;
30640 };
30641 
30642 
30643 
30645 class HPS_API TextKit : public Kit
30646 {
30647 public:
30649  TextKit();
30650 
30653  TextKit(TextKit const & in_kit);
30654 
30658  TextKit(TextKit && in_that);
30659 
30663  TextKit & operator=(TextKit && in_that);
30664 
30665  virtual ~TextKit();
30666 
30667  static const HPS::Type staticType = HPS::Type::TextKit;
30668  HPS::Type ObjectType() const { return staticType; };
30669 
30672  void Consume(TextKit & in_kit);
30673 
30676  void Set(TextKit const & in_kit);
30677 
30680  void Show(TextKit & out_kit) const;
30681 
30685  TextKit & operator=(TextKit const & in_kit);
30686 
30689  bool Empty() const;
30690 
30694  bool Equals(TextKit const & in_kit) const;
30695 
30699  bool operator==(TextKit const & in_kit) const;
30700 
30704  bool operator!=(TextKit const & in_kit) const;
30705 
30712  TextKit & SetPriority(int in_priority);
30713 
30716  TextKit & UnsetPriority();
30717 
30721  bool ShowPriority(int & out_priority) const;
30722 
30726  TextKit & SetPosition(Point const & in_position);
30727 
30731  TextKit & SetText(char const * in_string);
30732 
30736  TextKit & SetColor(RGBAColor const & in_rgba_color);
30737 
30741  TextKit & SetColorByIndex(float in_index);
30742 
30746  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
30747 
30753  TextKit & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
30754 
30758  TextKit & SetBold(bool in_state);
30759 
30763  TextKit & SetItalic(bool in_state);
30764 
30768  TextKit & SetOverline(bool in_state);
30769 
30773  TextKit & SetStrikethrough(bool in_state);
30774 
30778  TextKit & SetUnderline(bool in_state);
30779 
30784  TextKit & SetSlant(float in_angle);
30785 
30789  TextKit & SetLineSpacing(float in_multiplier);
30790 
30796  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
30797 
30801  TextKit & SetRotation(float in_angle);
30802 
30808  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
30809 
30814  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
30815 
30822  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
30823 
30829  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
30830 
30839  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
30840 
30848  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
30849 
30854  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
30855 
30861  TextKit & SetFont(char const * in_name);
30862 
30866  TextKit & SetTransform(Text::Transform in_trans);
30867 
30871  TextKit & SetRenderer(Text::Renderer in_rend);
30872 
30876  TextKit & SetPreference(Text::Preference in_pref);
30877 
30884  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
30885 
30889  TextKit & SetPath(Vector const & in_path);
30890 
30896  TextKit & SetSpacing(float in_multiplier);
30897 
30902  TextKit & SetBackground(bool in_state, char const * in_name);
30903 
30908  TextKit & SetBackground(char const * in_name);
30909 
30913  TextKit & SetBackground(bool in_state);
30914 
30919  TextKit & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
30920 
30926  TextKit & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
30927 
30934  TextKit & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
30935 
30940  TextKit & SetBackgroundStyle(char const * in_name);
30941 
30946  TextKit & SetLeaderLine(Point const & in_position, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30947 
30952  TextKit & SetLeaderLines(PointArray const & in_positions, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30953 
30959  TextKit & SetLeaderLines(size_t in_count, Point const in_positions [], Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30960 
30963  TextKit & UnsetPosition();
30964 
30967  TextKit & UnsetText();
30968 
30971  TextKit & UnsetColor();
30972 
30975  TextKit & UnsetModellingMatrix();
30976 
30979  TextKit & UnsetAlignment();
30980 
30983  TextKit & UnsetBold();
30984 
30987  TextKit & UnsetItalic();
30988 
30991  TextKit & UnsetOverline();
30992 
30995  TextKit & UnsetStrikethrough();
30996 
30999  TextKit & UnsetUnderline();
31000 
31003  TextKit & UnsetSlant();
31004 
31007  TextKit & UnsetLineSpacing();
31008 
31011  TextKit & UnsetRotation();
31012 
31015  TextKit & UnsetExtraSpace();
31016 
31019  TextKit & UnsetGreeking();
31020 
31023  TextKit & UnsetSizeTolerance();
31024 
31027  TextKit & UnsetSize();
31028 
31031  TextKit & UnsetFont();
31032 
31035  TextKit & UnsetTransform();
31036 
31039  TextKit & UnsetRenderer();
31040 
31043  TextKit & UnsetPreference();
31044 
31047  TextKit & UnsetPath();
31048 
31051  TextKit & UnsetSpacing();
31052 
31055  TextKit & UnsetBackground();
31056 
31059  TextKit & UnsetBackgroundMargins();
31060 
31063  TextKit & UnsetBackgroundStyle();
31064 
31067  TextKit & UnsetLeaderLines();
31068 
31071  TextKit & UnsetEverything();
31072 
31073 
31077  bool ShowPosition(Point & out_position) const;
31078 
31082  bool ShowText(UTF8 & out_string) const;
31083 
31089  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
31090 
31094  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
31095 
31101  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
31102 
31106  bool ShowBold(bool & out_state) const;
31107 
31111  bool ShowItalic(bool & out_state) const;
31112 
31116  bool ShowOverline(bool & out_state) const;
31117 
31121  bool ShowStrikethrough(bool & out_state) const;
31122 
31126  bool ShowUnderline(bool & out_state) const;
31127 
31131  bool ShowSlant(float & out_angle) const;
31132 
31136  bool ShowLineSpacing(float & out_multiplier) const;
31137 
31142  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
31143 
31149  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
31150 
31157  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
31158 
31164  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
31165 
31170  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
31171 
31175  bool ShowFont(UTF8 & out_name) const;
31176 
31180  bool ShowTransform(Text::Transform & out_trans) const;
31181 
31185  bool ShowRenderer(Text::Renderer & out_renderer) const;
31186 
31193  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
31194 
31198  bool ShowPath(Vector & out_path) const;
31199 
31203  bool ShowSpacing(float & out_multiplier) const;
31204 
31209  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
31210 
31215  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
31216 
31220  bool ShowBackgroundStyle(UTF8 & out_name) const;
31221 
31226  bool ShowLeaderLines(PointArray & out_positions, Text::LeaderLineSpace & out_space) const;
31227 
31235  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
31236 
31243  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
31244 
31252  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
31253 
31262  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, Text::RegionFitting & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
31263 
31276  TextKit & SetRegion(PointArray const & in_region, Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
31277 
31291  TextKit & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
31292 
31298  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
31299 
31302  TextKit & UnsetRegion();
31303 
31308  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
31309 
31314  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
31315 
31319  TextKit & UnsetUserData(intptr_t in_index);
31320 
31325  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
31326 
31330  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
31331 
31334  TextKit & UnsetAllUserData();
31335 
31337  size_t ShowUserDataCount() const;
31338 
31342  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
31343 
31348  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
31349 
31354  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
31355 };
31356 
31357 
31359 class HPS_API TextKey : public GeometryKey
31360 {
31361 public:
31363  TextKey();
31364 
31368  explicit TextKey(Key const & in_that);
31369 
31372  TextKey(TextKey const & in_that);
31373 
31377  TextKey & operator=(TextKey const & other);
31378 
31382  TextKey(TextKey && in_that);
31383 
31387  TextKey & operator=(TextKey && in_that);
31388 
31389  ~TextKey();
31390 
31391  static const HPS::Type staticType = HPS::Type::TextKey;
31392  HPS::Type ObjectType() const {return staticType;};
31393 
31396  void Consume(TextKit & in_kit);
31397 
31400  void Set(TextKit const & in_kit);
31401 
31404  void Show(TextKit & out_kit) const;
31405 
31408  TextKey & SetTextAttribute(TextAttributeKit const & in_kit);
31409 
31413  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
31414 
31418  TextKey & SetPosition(Point const & in_position);
31419 
31423  TextKey & SetText(char const * in_string);
31424 
31429  TextKey & SetColor(RGBAColor const & in_rgba_color);
31430 
31434  TextKey & SetColorByIndex(float in_index);
31435 
31439  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
31440 
31446  TextKey & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
31447 
31451  TextKey & SetBold(bool in_state);
31452 
31456  TextKey & SetItalic(bool in_state);
31457 
31461  TextKey & SetOverline(bool in_state);
31462 
31466  TextKey & SetStrikethrough(bool in_state);
31467 
31471  TextKey & SetUnderline(bool in_state);
31472 
31477  TextKey & SetSlant(float in_angle);
31478 
31483  TextKey & SetLineSpacing(float in_multiplier);
31484 
31490  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
31491 
31495  TextKey & SetRotation(float in_angle);
31496 
31502  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
31503 
31508  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
31509 
31516  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
31517 
31523  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
31524 
31533  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
31534 
31542  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
31543 
31548  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
31549 
31555  TextKey & SetFont(char const * in_name);
31556 
31560  TextKey & SetTransform(Text::Transform in_transform);
31561 
31565  TextKey & SetRenderer(Text::Renderer in_renderer);
31566 
31570  TextKey & SetPreference(Text::Preference in_preference);
31571 
31579  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
31580 
31585  TextKey & SetPath(Vector const & in_path);
31586 
31592  TextKey & SetSpacing(float in_multiplier);
31593 
31606  TextKey & SetRegion(PointArray const & in_region, Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
31607 
31621  TextKey & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, Text::RegionFitting in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
31622 
31627  TextKey & SetBackground(bool in_state, char const * in_name);
31628 
31633  TextKey & SetBackground(char const * in_name);
31634 
31638  TextKey & SetBackground(bool in_state);
31639 
31644  TextKey & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
31645 
31651  TextKey & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
31652 
31659  TextKey & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
31660 
31665  TextKey & SetBackgroundStyle(char const * in_name);
31666 
31671  TextKey & SetLeaderLine(Point const & in_position, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
31672 
31677  TextKey & SetLeaderLines(PointArray const & in_positions, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
31678 
31684  TextKey & SetLeaderLines(size_t in_count, Point const in_positions [], Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
31685 
31686 
31689  TextKey & UnsetColor();
31690 
31693  TextKey & UnsetModellingMatrix();
31694 
31697  TextKey & UnsetAlignment();
31698 
31701  TextKey & UnsetBold();
31702 
31705  TextKey & UnsetItalic();
31706 
31709  TextKey & UnsetOverline();
31710 
31713  TextKey & UnsetStrikethrough();
31714 
31717  TextKey & UnsetUnderline();
31718 
31721  TextKey & UnsetSlant();
31722 
31725  TextKey & UnsetLineSpacing();
31726 
31729  TextKey & UnsetRotation();
31730 
31733  TextKey & UnsetExtraSpace();
31734 
31737  TextKey & UnsetGreeking();
31738 
31741  TextKey & UnsetSizeTolerance();
31742 
31745  TextKey & UnsetSize();
31746 
31749  TextKey & UnsetFont();
31750 
31753  TextKey & UnsetTransform();
31754 
31757  TextKey & UnsetRenderer();
31758 
31761  TextKey & UnsetPreference();
31762 
31765  TextKey & UnsetPath();
31766 
31769  TextKey & UnsetSpacing();
31770 
31773  TextKey & UnsetRegion();
31774 
31777  TextKey & UnsetBackground();
31778 
31781  TextKey & UnsetBackgroundMargins();
31782 
31785  TextKey & UnsetBackgroundStyle();
31786 
31789  TextKey & UnsetLeaderLines();
31790 
31793  TextKey & UnsetEverything();
31794 
31795 
31799  bool ShowPosition(Point & out_position) const;
31800 
31804  bool ShowText(UTF8 & out_string) const;
31805 
31811  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
31812 
31816  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
31817 
31823  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
31824 
31828  bool ShowBold(bool & out_state) const;
31829 
31833  bool ShowItalic(bool & out_state) const;
31834 
31838  bool ShowOverline(bool & out_state) const;
31839 
31843  bool ShowStrikethrough(bool & out_state) const;
31844 
31848  bool ShowUnderline(bool & out_state) const;
31849 
31853  bool ShowSlant(float & out_angle) const;
31854 
31858  bool ShowLineSpacing(float & out_multiplier) const;
31859 
31864  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
31865 
31871  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
31872 
31879  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
31880 
31886  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
31887 
31892  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
31893 
31897  bool ShowFont(UTF8 & out_name) const;
31898 
31902  bool ShowTransform(Text::Transform & out_trans) const;
31903 
31907  bool ShowRenderer(Text::Renderer & out_renderer) const;
31908 
31915  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
31916 
31920  bool ShowPath(Vector & out_path) const;
31921 
31925  bool ShowSpacing(float & out_multiplier) const;
31926 
31935  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, Text::RegionFitting & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
31936 
31941  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
31942 
31947  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
31948 
31952  bool ShowBackgroundStyle(UTF8 & out_name) const;
31953 
31958  bool ShowLeaderLines(PointArray & out_positions, Text::LeaderLineSpace & out_space) const;
31959 
31967  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
31968 
31975  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
31976 
31984  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
31985 };
31986 
31987 
31989 class HPS_API ShellOptimizationOptionsKit : public Kit
31990 {
31991 public:
31994 
31998 
32003 
32004  virtual ~ShellOptimizationOptionsKit();
32005 
32006  static const HPS::Type staticType = HPS::Type::ShellOptimizationOptionsKit;
32007  HPS::Type ObjectType() const { return staticType; };
32008 
32011  void Consume(ShellOptimizationOptionsKit & in_kit);
32012 
32015  void Set(ShellOptimizationOptionsKit const & in_kit);
32016 
32019  void Show(ShellOptimizationOptionsKit & out_kit) const;
32020 
32024  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
32025 
32030 
32033  bool Empty() const;
32034 
32038  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
32039 
32043  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
32044 
32048  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
32049 
32053  static ShellOptimizationOptionsKit GetDefault();
32054 
32055 
32059  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
32060 
32065  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
32066 
32071  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
32072 
32077  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
32078 
32079 
32082  ShellOptimizationOptionsKit & UnsetNormalTolerance();
32083 
32086  ShellOptimizationOptionsKit & UnsetTolerance();
32087 
32090  ShellOptimizationOptionsKit & UnsetOrphanElimination();
32091 
32094  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
32095 
32098  ShellOptimizationOptionsKit & UnsetEverything();
32099 
32100 
32104  bool ShowNormalTolerance(float & out_normal_tolerance) const;
32105 
32110  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
32111 
32115  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
32116 
32121  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
32122 };
32123 
32124 
32128 class HPS_API ShellRelationOptionsKit : public Kit
32129 {
32130 public:
32133 
32137 
32142 
32146  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
32147 
32148  virtual ~ShellRelationOptionsKit();
32149 
32150  static const HPS::Type staticType = HPS::Type::ShellRelationOptionsKit;
32151  HPS::Type ObjectType() const { return staticType; };
32152 
32156  static ShellRelationOptionsKit GetDefault();
32157 
32160  void Consume(ShellRelationOptionsKit & in_kit);
32161 
32164  void Set(ShellRelationOptionsKit const & in_kit);
32165 
32168  void Show(ShellRelationOptionsKit & out_kit) const;
32169 
32173  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
32174 
32177  bool Empty() const;
32178 
32182  bool Equals(ShellRelationOptionsKit const & in_kit) const;
32183 
32187  bool operator==(ShellRelationOptionsKit const & in_kit) const;
32188 
32192  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
32193 
32194 
32198  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
32199 
32203  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
32204 
32209  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
32210 
32214  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
32215 
32216 
32219  ShellRelationOptionsKit & UnsetTolerance();
32220 
32223  ShellRelationOptionsKit & UnsetTest();
32224 
32227  ShellRelationOptionsKit & UnsetTreeContext();
32228 
32231  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
32232 
32235  ShellRelationOptionsKit & UnsetEverything();
32236 
32237 
32241  bool ShowTolerance(float & out_tolerance) const;
32242 
32246  bool ShowTest(Shell::RelationTest & out_test) const;
32247 
32251  bool ShowTreeContext(TreeContext & out_tree_context) const;
32252 
32256  bool ShowNearestFaceCalculation(bool & out_state) const;
32257 };
32258 
32260 class HPS_API ShellRelationResultsKit : public Kit
32261 {
32262 public:
32265 
32269 
32274 
32278  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
32279 
32280  virtual ~ShellRelationResultsKit();
32281 
32282  static const HPS::Type staticType = HPS::Type::ShellRelationResultsKit;
32283  HPS::Type ObjectType() const { return staticType; };
32284 
32287  void Consume(ShellRelationResultsKit & in_kit);
32288 
32291  void Set(ShellRelationResultsKit const & in_kit);
32292 
32295  void Show(ShellRelationResultsKit & out_kit) const;
32296 
32300  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
32301 
32304  bool Empty() const;
32305 
32309  bool Equals(ShellRelationResultsKit const & in_kit) const;
32310 
32314  bool operator==(ShellRelationResultsKit const & in_kit) const;
32315 
32319  bool operator!=(ShellRelationResultsKit const & in_kit) const;
32320 
32321 
32325  bool ShowRelations(ShellRelationArray & out_results) const;
32326 
32330  bool ShowNearestFaces(SizeTArray & out_faces) const;
32331 
32335  bool ShowDistances(FloatArray & out_distances) const;
32336 };
32337 
32338 
32340 class HPS_API ShellKit : public Kit
32341 {
32342 public:
32344  ShellKit();
32345 
32348  ShellKit(ShellKit const & in_kit);
32349 
32353  ShellKit(ShellKit && in_that);
32354 
32358  ShellKit & operator=(ShellKit && in_that);
32359 
32360  virtual ~ShellKit();
32361 
32362  static const HPS::Type staticType = HPS::Type::ShellKit;
32363  HPS::Type ObjectType() const { return staticType; };
32364 
32367  void Consume(ShellKit & in_kit);
32368 
32371  void Set(ShellKit const & in_kit);
32372 
32375  void Show(ShellKit & out_kit) const;
32376 
32379  size_t GetPointCount() const;
32380 
32383  size_t GetFaceCount() const;
32384 
32388  ShellKit & operator=(ShellKit const & in_kit);
32389 
32392  bool Empty() const;
32393 
32397  bool Equals(ShellKit const & in_kit) const;
32398 
32402  bool operator==(ShellKit const & in_kit) const;
32403 
32407  bool operator!=(ShellKit const & in_kit) const;
32408 
32415  ShellKit & SetPriority(int in_priority);
32416 
32419  ShellKit & UnsetPriority();
32420 
32424  bool ShowPriority(int & out_priority) const;
32425 
32426 
32427 
32431  ShellKit & SetPoints(PointArray const & in_points);
32432 
32437  ShellKit & SetPoints(size_t in_count, Point const in_points []);
32438 
32442  ShellKit & SetFacelist(IntArray const & in_facelist);
32443 
32448  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
32449 
32453  ShellKit & SetTristrips(IntArray const & in_tristrips);
32454 
32459  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
32460 
32463  ShellKit & UnsetPoints();
32464 
32467  ShellKit & UnsetFacelist();
32468 
32471  ShellKit & UnsetTristrips();
32472 
32475  ShellKit & UnsetEverything();
32476 
32480  bool ShowPoints(PointArray & out_points) const;
32481 
32487  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32488 
32493  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32494 
32500  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32501 
32505  bool ShowFacelist(IntArray & out_facelist) const;
32506 
32516  bool ShowTristrips(IntArray & out_tristrips) const;
32517 
32523  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
32524 
32531  ShellKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
32532 
32539  ShellKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
32540 
32546  ShellKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
32547 
32553  ShellKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
32554 
32560  ShellKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
32561 
32567  ShellKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
32568 
32575  ShellKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
32576 
32583  ShellKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
32584 
32590  ShellKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
32591 
32597  ShellKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
32598 
32605  ShellKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
32606 
32613  ShellKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
32614 
32622  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
32623 
32631  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
32632 
32640  ShellKit & UnsetEdgeColors();
32641 
32646  ShellKit & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
32647 
32653  ShellKit & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
32654 
32657  ShellKit & UnsetEdgeVisibilities();
32658 
32661  ShellKit & UnsetEdgeEverything();
32662 
32667  ShellKit & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
32668 
32674  ShellKit & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
32675 
32676 
32685  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
32686 
32693  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32694 
32700  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32701 
32708  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32709 
32716  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32717 
32724  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32725 
32732  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32733 
32739  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32740 
32741 
32748  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32749 
32755  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32756 
32763  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32764 
32771  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32772 
32779  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32780 
32787  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32788 
32794  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32795 
32796 
32803  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
32804 
32810  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
32811 
32818  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32819 
32826  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
32827 
32834  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
32835 
32842  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32843 
32849  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32850 
32851 
32857  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32858 
32863  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32864 
32870  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32871 
32877  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32878 
32883  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32884 
32890  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32891 
32896  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32897 
32898 
32905  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32906 
32913  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32914 
32923  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);
32924 
32932  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32933 
32934 
32940  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32941 
32946  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32947 
32953  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32954 
32960  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32961 
32966  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32967 
32973  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32974 
32979  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32980 
32981 
32984  ShellKit & UnsetMaterialMapping();
32985 
32986 
32989  ShellKit & UnsetVertexColors();
32990 
32995  ShellKit & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
32996 
33001  ShellKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
33002 
33008  ShellKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Shell::Component in_apply_to);
33009 
33014  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
33015 
33019  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
33020 
33021 
33025  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
33026 
33032  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
33033 
33038  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
33039 
33040 
33043  ShellKit & UnsetVertexNormals();
33044 
33049  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
33050 
33054  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
33055 
33056 
33059  ShellKit & UnsetVertexParameters();
33060 
33065  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
33066 
33070  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
33071 
33072 
33075  ShellKit & UnsetVertexVisibilities();
33076 
33081  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
33082 
33086  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
33087 
33088 
33091  ShellKit & UnsetVertexEverything();
33092 
33093 
33097  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
33098 
33099 
33111  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
33112  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33113 
33127  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
33128  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33129 
33144  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
33145  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33146 
33153  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33154 
33163  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33164 
33173  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
33174 
33175 
33183  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
33184 
33192  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33193 
33203  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
33204 
33214  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33215 
33225  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
33226 
33236  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33237 
33238 
33245  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33246 
33255  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33256 
33265  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
33266 
33267 
33268 
33274  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
33275 
33280  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
33281 
33287  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
33288 
33294  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
33295 
33300  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
33301 
33307  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
33308 
33313  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
33314 
33315 
33321  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
33322 
33327  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
33328 
33334  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33335 
33341  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33342 
33347  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33348 
33354  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33355 
33360  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33361 
33362 
33368  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33369 
33374  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33375 
33381  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33382 
33388  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33389 
33394  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33395 
33401  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33402 
33407  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33408 
33409 
33415  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33416 
33421  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33422 
33428  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33429 
33435  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33436 
33441  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33442 
33448  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33449 
33454  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33455 
33456 
33459  ShellKit & UnsetFaceColors();
33460 
33465  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33466 
33470  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
33471 
33472 
33475  ShellKit & UnsetFaceNormals();
33476 
33481  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33482 
33486  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
33487 
33488 
33491  ShellKit & UnsetFaceVisibilities();
33492 
33497  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33498 
33502  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
33503 
33508  ShellKit & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
33509 
33514  ShellKit & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
33515 
33518  ShellKit & UnsetFaceEverything();
33519 
33527  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33528 
33538  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33539 
33550  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33551 
33552 
33559  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33560 
33569  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33570 
33579  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33580 
33587  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33588 
33597  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33598 
33607  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33608 
33609 
33616  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33617 
33623  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33624 
33630  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
33631 
33637  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33638 
33644  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33645 
33646 
33653  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
33654 
33660  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
33661 
33667  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
33668 
33677  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
33678 
33686  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
33687 
33690  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
33691 
33696  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33697 
33702  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33703 
33708  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33709 
33715  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
33716 
33721  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
33722 
33727  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
33728 
33732  ShellKit & UnsetUserData(intptr_t in_index);
33733 
33738  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
33739 
33743  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
33744 
33747  ShellKit & UnsetAllUserData();
33748 
33750  size_t ShowUserDataCount() const;
33751 
33755  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
33756 
33761  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
33762 
33767  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
33768 };
33769 
33770 
33771 
33773 class HPS_API ShellKey : public GeometryKey
33774 {
33775 public:
33777  ShellKey();
33778 
33783  explicit ShellKey(Key const & in_that);
33784 
33787  ShellKey(ShellKey const & in_that);
33788 
33792  ShellKey & operator=(ShellKey const & other);
33793 
33797  ShellKey(ShellKey && in_that);
33798 
33802  ShellKey & operator=(ShellKey && in_that);
33803 
33804  ~ShellKey();
33805 
33806  static const HPS::Type staticType = HPS::Type::ShellKey;
33807  HPS::Type ObjectType() const { return staticType; };
33808 
33811  void Consume(ShellKit & in_kit);
33812 
33815  void Set(ShellKit const & in_kit);
33816 
33819  void Show(ShellKit & out_kit) const;
33820 
33823  size_t GetPointCount() const;
33824 
33827  size_t GetFaceCount() const;
33828 
33829 
33833  ShellKey & SetPoints(PointArray const & in_points);
33834 
33839  ShellKey & SetPoints(size_t in_count, Point const in_points []);
33840 
33844  ShellKey & SetFacelist(IntArray const & in_facelist);
33845 
33850  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
33851 
33855  ShellKey & SetTristrips(IntArray const & in_tristrips);
33856 
33861  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
33862 
33867  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
33868 
33871  ShellKey & UnsetPoints();
33872 
33875  ShellKey & UnsetFacelist();
33876 
33879  ShellKey & UnsetTristrips();
33880 
33883  ShellKey & UnsetMaterialMapping();
33884 
33887  ShellKey & UnsetEverything();
33888 
33892  bool ShowPoints(PointArray & out_points) const;
33893 
33899  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33900 
33905  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33906 
33912  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33913 
33917  bool ShowFacelist(IntArray & out_facelist) const;
33918 
33928  bool ShowTristrips(IntArray & out_tristrips) const;
33929 
33942  bool ShowTristrips(IntArray & out_tristrips, IntArray & out_face_indices) const;
33943 
33947  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
33948 
33955  ShellKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
33956 
33963  ShellKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
33964 
33970  ShellKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
33971 
33977  ShellKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
33978 
33984  ShellKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
33985 
33991  ShellKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
33992 
33999  ShellKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
34000 
34007  ShellKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
34008 
34014  ShellKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
34015 
34021  ShellKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
34022 
34029  ShellKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
34030 
34037  ShellKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
34038 
34046  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
34047 
34055  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
34056 
34059  ShellKey & UnsetEdgeColors();
34060 
34065  ShellKey & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
34066 
34072  ShellKey & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
34073 
34076  ShellKey & UnsetEdgeVisibilities();
34077 
34080  ShellKey & UnsetEdgeEverything();
34081 
34086  ShellKey & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
34087 
34093  ShellKey & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
34094 
34095 
34104  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
34105 
34112  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
34113 
34120  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
34121 
34128  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
34129 
34136  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
34137 
34144  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
34145 
34152  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
34153 
34159  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
34160 
34161 
34168  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
34169 
34176  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
34177 
34184  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
34185 
34192  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
34193 
34200  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
34201 
34208  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
34209 
34215  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
34216 
34217 
34224  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
34225 
34232  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
34233 
34240  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
34241 
34248  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
34249 
34256  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
34257 
34264  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
34265 
34271  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
34272 
34273 
34279  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
34280 
34286  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
34287 
34293  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
34294 
34300  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
34301 
34306  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
34307 
34313  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
34314 
34319  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
34320 
34321 
34329  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
34330 
34337  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
34338 
34347  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);
34348 
34356  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
34357 
34358 
34364  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
34365 
34371  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
34372 
34378  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
34379 
34385  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
34386 
34391  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
34392 
34398  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
34399 
34404  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
34405 
34410  ShellKey & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
34411 
34416  ShellKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
34417 
34423  ShellKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Shell::Component in_apply_to);
34424 
34427  ShellKey & UnsetVertexColors();
34428 
34433  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
34434 
34438  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
34439 
34440 
34444  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
34445 
34451  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
34452 
34457  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
34458 
34459 
34462  ShellKey & UnsetVertexNormals();
34463 
34468  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
34469 
34473  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
34474 
34475 
34478  ShellKey & UnsetVertexParameters();
34479 
34484  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
34485 
34489  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
34490 
34491 
34494  ShellKey & UnsetVertexVisibilities();
34495 
34500  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
34501 
34505  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
34506 
34507 
34510  ShellKey & UnsetVertexEverything();
34511 
34512 
34524  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
34525  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34526 
34540  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
34541  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34542 
34557  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
34558  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34559 
34560 
34567  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
34568 
34577  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
34578 
34587  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
34588 
34596  bool ShowNetVertexNormals(VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
34597 
34607  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
34608 
34616  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
34617 
34625  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34626 
34636  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
34637 
34647  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34648 
34658  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
34659 
34669  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34670 
34671 
34678  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
34679 
34688  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
34689 
34698  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
34699 
34700 
34706  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
34707 
34713  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
34714 
34720  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
34721 
34727  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
34728 
34733  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
34734 
34740  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
34741 
34746  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
34747 
34748 
34754  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
34755 
34761  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
34762 
34768  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
34769 
34775  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
34776 
34781  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
34782 
34788  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
34789 
34794  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
34795 
34796 
34802  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
34803 
34809  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
34810 
34816  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
34817 
34823  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
34824 
34829  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
34830 
34836  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
34837 
34842  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
34843 
34844 
34850  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
34851 
34857  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
34858 
34864  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
34865 
34871  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
34872 
34877  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
34878 
34884  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
34885 
34890  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
34891 
34892 
34895  ShellKey & UnsetFaceColors();
34896 
34901  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
34902 
34906  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
34907 
34912  ShellKey & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
34913 
34918  ShellKey & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
34919 
34922  ShellKey & UnsetFaceNormals();
34923 
34928  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
34929 
34933  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
34934 
34935 
34938  ShellKey & UnsetFaceVisibilities();
34939 
34944  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
34945 
34949  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
34950 
34951 
34954  ShellKey & UnsetFaceEverything();
34955 
34963  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34964 
34974  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34975 
34986  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34987 
34994  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
34995 
35004  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
35005 
35014  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
35015 
35016 
35022  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
35023 
35030  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
35031 
35032 
35039  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
35040 
35049  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
35050 
35059  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
35060 
35061 
35068  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
35069 
35075  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
35076 
35082  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
35083 
35089  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
35090 
35096  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
35097 
35098 
35105  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
35106 
35112  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
35113 
35119  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
35120 
35129  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
35130 
35138  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
35139 
35142  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
35143 
35148  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
35149 
35154  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
35155 
35160  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
35161 };
35162 
35163 
35164 
35166 class HPS_API MeshKit : public Kit
35167 {
35168 public:
35170  MeshKit();
35171 
35174  MeshKit(MeshKit const & in_kit);
35175 
35179  MeshKit(MeshKit && in_that);
35180 
35184  MeshKit & operator=(MeshKit && in_that);
35185 
35186  virtual ~MeshKit();
35187 
35188  static const HPS::Type staticType = HPS::Type::MeshKit;
35189  HPS::Type ObjectType() const { return staticType; };
35190 
35193  void Consume(MeshKit & in_kit);
35194 
35197  void Set(MeshKit const & in_kit);
35198 
35201  void Show(MeshKit & out_kit) const;
35202 
35206  MeshKit & operator=(MeshKit const & in_kit);
35207 
35210  bool Empty() const;
35211 
35215  bool Equals(MeshKit const & in_kit) const;
35216 
35220  bool operator==(MeshKit const & in_kit) const;
35221 
35225  bool operator!=(MeshKit const & in_kit) const;
35226 
35229  size_t GetPointCount() const;
35230 
35237  MeshKit & SetPriority(int in_priority);
35238 
35241  MeshKit & UnsetPriority();
35242 
35246  bool ShowPriority(int & out_priority) const;
35247 
35251  MeshKit & SetPoints(PointArray const & in_points);
35252 
35257  MeshKit & SetPoints(size_t in_count, Point const in_points []);
35258 
35264  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
35265 
35272  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
35273 
35277  MeshKit & SetRows(size_t in_rows);
35278 
35282  MeshKit & SetColumns(size_t in_columns);
35283 
35286  MeshKit & UnsetPoints();
35287 
35290  MeshKit & UnsetRows();
35291 
35294  MeshKit & UnsetColumns();
35295 
35298  MeshKit & UnsetEverything();
35299 
35303  bool ShowPoints(PointArray & out_points) const;
35304 
35310  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
35311 
35316  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
35317 
35323  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
35324 
35330  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
35331 
35335  bool ShowRows(size_t & out_rows) const;
35336 
35340  bool ShowColumns(size_t & out_columns) const;
35341 
35347  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
35348 
35355  MeshKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
35356 
35363  MeshKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
35364 
35370  MeshKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
35371 
35377  MeshKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
35378 
35384  MeshKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
35385 
35391  MeshKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
35392 
35399  MeshKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
35400 
35407  MeshKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
35408 
35414  MeshKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
35415 
35421  MeshKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
35422 
35429  MeshKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
35430 
35437  MeshKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
35438 
35446  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
35447 
35455  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
35456 
35464  MeshKit & UnsetEdgeColors();
35465 
35470  MeshKit & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
35471 
35477  MeshKit & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
35478 
35481  MeshKit & UnsetEdgeVisibilities();
35482 
35485  MeshKit & UnsetEdgeEverything();
35486 
35491  MeshKit & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
35492 
35498  MeshKit & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
35499 
35500 
35509  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
35510 
35517  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35518 
35524  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35525 
35532  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35533 
35540  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35541 
35548  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35549 
35556  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35557 
35563  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35564 
35565 
35572  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35573 
35579  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35580 
35587  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35588 
35595  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35596 
35603  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35604 
35611  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35612 
35618  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35619 
35620 
35627  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35628 
35634  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
35635 
35642  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35643 
35650  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35651 
35658  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
35659 
35666  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35667 
35673  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35674 
35675 
35681  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
35682 
35687  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
35688 
35694  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
35695 
35701  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
35702 
35707  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
35708 
35714  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
35715 
35720  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
35721 
35722 
35729  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
35730 
35737  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
35738 
35747  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);
35748 
35756  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
35757 
35758 
35764  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
35765 
35770  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
35771 
35777  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
35778 
35784  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
35785 
35790  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
35791 
35797  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
35798 
35803  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
35804 
35805 
35808  MeshKit & UnsetMaterialMapping();
35809 
35812  MeshKit & UnsetVertexColors();
35813 
35818  MeshKit & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
35819 
35824  MeshKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
35825 
35831  MeshKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Mesh::Component in_apply_to);
35832 
35837  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
35838 
35842  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
35843 
35844 
35848  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
35849 
35855  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
35856 
35861  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
35862 
35863 
35866  MeshKit & UnsetVertexNormals();
35867 
35872  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
35873 
35877  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
35878 
35879 
35882  MeshKit & UnsetVertexParameters();
35883 
35888  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
35889 
35893  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
35894 
35895 
35898  MeshKit & UnsetVertexVisibilities();
35899 
35904  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
35905 
35909  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
35910 
35911 
35914  MeshKit & UnsetVertexEverything();
35915 
35916 
35920  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
35921 
35933  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35934  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35935 
35949  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35950  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35951 
35966  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35967  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35968 
35969 
35976  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
35977 
35986  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
35987 
35996  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
35997 
36005  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
36006 
36014  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
36015 
36025  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
36026 
36036  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
36037 
36047  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
36048 
36058  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
36059 
36066  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
36067 
36076  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
36077 
36086  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
36087 
36088 
36094  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
36095 
36100  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
36101 
36107  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
36108 
36114  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
36115 
36120  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
36121 
36127  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
36128 
36133  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
36134 
36135 
36141  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
36142 
36147  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
36148 
36154  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
36155 
36161  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
36162 
36167  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
36168 
36174  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
36175 
36180  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
36181 
36182 
36188  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
36189 
36194  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
36195 
36201  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
36202 
36208  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
36209 
36214  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
36215 
36221  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
36222 
36227  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
36228 
36229 
36235  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
36236 
36241  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
36242 
36248  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
36249 
36255  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
36256 
36261  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
36262 
36268  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
36269 
36274  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
36275 
36276 
36279  MeshKit & UnsetFaceColors();
36280 
36285  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
36286 
36290  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
36291 
36296  MeshKit & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
36297 
36302  MeshKit & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
36303 
36306  MeshKit & UnsetFaceNormals();
36307 
36312  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
36313 
36317  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
36318 
36319 
36322  MeshKit & UnsetFaceVisibilities();
36323 
36328  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
36329 
36333  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
36334 
36335 
36338  MeshKit & UnsetFaceEverything();
36339 
36347  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36348 
36358  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36359 
36370  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36371 
36372 
36379  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
36380 
36389  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
36390 
36399  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
36400 
36407  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
36408 
36417  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
36418 
36427  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
36428 
36434  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
36435 
36440  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
36441 
36446  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
36447 
36451  MeshKit & UnsetUserData(intptr_t in_index);
36452 
36457  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
36458 
36462  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
36463 
36466  MeshKit & UnsetAllUserData();
36467 
36469  size_t ShowUserDataCount() const;
36470 
36474  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
36475 
36480  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
36481 
36486  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
36487 
36488 };
36489 
36490 
36491 
36493 class HPS_API MeshKey : public GeometryKey
36494 {
36495 public:
36497  MeshKey();
36498 
36503  explicit MeshKey(Key const & in_that);
36504 
36507  MeshKey(MeshKey const & in_that);
36508 
36512  MeshKey & operator=(MeshKey const & in_that);
36513 
36517  MeshKey(MeshKey && in_that);
36518 
36522  MeshKey & operator=(MeshKey && in_that);
36523 
36524  ~MeshKey();
36525 
36526  static const HPS::Type staticType = HPS::Type::MeshKey;
36527  HPS::Type ObjectType() const { return staticType; };
36528 
36531  void Consume(MeshKit & in_kit);
36532 
36535  void Set(MeshKit const & in_kit);
36536 
36539  void Show(MeshKit & out_kit) const;
36540 
36543  size_t GetPointCount() const;
36544 
36550  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
36551 
36558  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
36559 
36563  bool ShowPoints(PointArray & out_points) const;
36564 
36570  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
36571 
36576  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
36577 
36583  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
36584 
36590  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
36591 
36595  bool ShowRows(size_t & out_rows) const;
36596 
36600  bool ShowColumns(size_t & out_columns) const;
36601 
36602 
36607  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
36608 
36611  MeshKey & UnsetMaterialMapping();
36612 
36616  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
36617 
36624  MeshKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
36625 
36632  MeshKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
36633 
36639  MeshKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
36640 
36646  MeshKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
36647 
36653  MeshKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
36654 
36660  MeshKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
36661 
36668  MeshKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
36669 
36676  MeshKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
36677 
36683  MeshKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
36684 
36690  MeshKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
36691 
36698  MeshKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
36699 
36706  MeshKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
36707 
36715  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
36716 
36724  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
36725 
36733  MeshKey & UnsetEdgeColors();
36734 
36739  MeshKey & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
36740 
36746  MeshKey & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
36747 
36750  MeshKey & UnsetEdgeVisibilities();
36751 
36754  MeshKey & UnsetEdgeEverything();
36755 
36760  MeshKey & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
36761 
36767  MeshKey & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
36768 
36769 
36778  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
36779 
36786  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36787 
36794  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36795 
36802  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36803 
36810  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36811 
36818  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36819 
36826  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36827 
36833  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36834 
36835 
36842  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36843 
36850  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36851 
36858  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36859 
36866  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36867 
36874  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
36875 
36882  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36883 
36889  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
36890 
36891 
36898  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36899 
36906  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
36907 
36914  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
36915 
36922  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
36923 
36930  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
36931 
36938  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
36939 
36945  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
36946 
36952  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
36953 
36959  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
36960 
36966  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
36967 
36973  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
36974 
36979  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
36980 
36986  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
36987 
36992  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
36993 
36994 
37002  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
37003 
37010  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
37011 
37020  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);
37021 
37029  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
37030 
37031 
37037  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
37038 
37044  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
37045 
37051  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
37052 
37058  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
37059 
37064  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
37065 
37071  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
37072 
37077  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
37078 
37079 
37082  MeshKey & UnsetVertexColors();
37083 
37088  MeshKey & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
37089 
37094  MeshKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
37095 
37101  MeshKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Mesh::Component in_apply_to);
37102 
37107  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
37108 
37112  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
37113 
37114 
37118  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
37119 
37125  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
37126 
37131  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
37132 
37133 
37136  MeshKey & UnsetVertexNormals();
37137 
37142  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
37143 
37147  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
37148 
37149 
37152  MeshKey & UnsetVertexParameters();
37153 
37158  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
37159 
37163  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
37164 
37165 
37168  MeshKey & UnsetVertexVisibilities();
37169 
37174  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
37175 
37179  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
37180 
37181 
37184  MeshKey & UnsetVertexEverything();
37185 
37188  MeshKey & UnsetEverything();
37189 
37190 
37202  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
37203  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
37204 
37218  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
37219  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
37220 
37235  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
37236  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
37237 
37238 
37245  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
37246 
37255  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
37256 
37265  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
37266 
37274  bool ShowNetVertexNormals(VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
37275 
37285  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals, Drawing::Handedness in_polygon_handedness = Drawing::Handedness::None) const;
37286 
37294  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
37295 
37303  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
37304 
37314  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
37315 
37325  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
37326 
37336  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
37337 
37347  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
37348 
37349 
37356  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
37357 
37366  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
37367 
37376  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
37377 
37378 
37384  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
37385 
37391  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
37392 
37398  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
37399 
37405  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
37406 
37411  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
37412 
37418  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
37419 
37424  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
37425 
37426 
37432  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
37433 
37439  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
37440 
37446  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
37447 
37453  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
37454 
37459  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
37460 
37466  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
37467 
37472  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
37473 
37474 
37480  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
37481 
37487  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
37488 
37494  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
37495 
37501  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
37502 
37507  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
37508 
37514  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
37515 
37520  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
37521 
37522 
37528  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
37529 
37535  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
37536 
37542  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
37543 
37549  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
37550 
37555  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
37556 
37562  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
37563 
37568  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
37569 
37570 
37573  MeshKey & UnsetFaceColors();
37574 
37579  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
37580 
37584  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
37585 
37590  MeshKey & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
37591 
37596  MeshKey & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
37597 
37600  MeshKey & UnsetFaceNormals();
37601 
37606  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
37607 
37611  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
37612 
37613 
37616  MeshKey & UnsetFaceVisibilities();
37617 
37622  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
37623 
37627  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
37628 
37629 
37632  MeshKey & UnsetFaceEverything();
37633 
37641  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
37642 
37652  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
37653 
37664  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
37665 
37672  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
37673 
37682  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
37683 
37692  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
37693 
37700  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
37701 
37710  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
37711 
37720  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
37721 
37730  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[]);
37731 
37739  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);
37740 };
37741 
37742 
37743 
37744 
37746 class HPS_API PolygonKit : public Kit
37747 {
37748 public:
37750  PolygonKit();
37751 
37754  PolygonKit(PolygonKit const & in_kit);
37755 
37759  PolygonKit(PolygonKit && in_that);
37760 
37764  PolygonKit & operator=(PolygonKit && in_that);
37765 
37766  virtual ~PolygonKit();
37767 
37768  static const HPS::Type staticType = HPS::Type::PolygonKit;
37769  HPS::Type ObjectType() const { return staticType; };
37770 
37773  void Consume(PolygonKit & in_kit);
37774 
37777  void Set(PolygonKit const & in_kit);
37778 
37781  void Show(PolygonKit & out_kit) const;
37782 
37786  PolygonKit & operator=(PolygonKit const & in_kit);
37787 
37790  bool Empty() const;
37791 
37795  bool Equals(PolygonKit const & in_kit) const;
37796 
37800  bool operator==(PolygonKit const & in_kit) const;
37801 
37805  bool operator!=(PolygonKit const & in_kit) const;
37806 
37809  size_t GetPointCount() const;
37810 
37817  PolygonKit & SetPriority(int in_priority);
37818 
37821  PolygonKit & UnsetPriority();
37822 
37826  bool ShowPriority(int & out_priority) const;
37827 
37828 
37832  PolygonKit & SetPoints(PointArray const & in_points);
37833 
37838  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
37839 
37842  PolygonKit & UnsetPoints();
37843 
37846  PolygonKit & UnsetEverything();
37847 
37851  bool ShowPoints(PointArray & out_points) const;
37852 
37858  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
37859 
37864  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
37865 
37871  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
37872 
37878  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
37879 
37884  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
37885 
37890  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
37891 
37897  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
37898 
37903  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
37904 
37910  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
37911 
37916  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
37917 
37922  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
37923 
37927  PolygonKit & UnsetUserData(intptr_t in_index);
37928 
37933  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
37934 
37938  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
37939 
37942  PolygonKit & UnsetAllUserData();
37943 
37945  size_t ShowUserDataCount() const;
37946 
37950  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
37951 
37956  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
37957 
37962  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
37963 
37971  PointArray Triangulate() const;
37972 };
37973 
37974 
37976 class HPS_API PolygonKey : public GeometryKey
37977 {
37978 public:
37980  PolygonKey();
37981 
37986  explicit PolygonKey(Key const & in_that);
37987 
37990  PolygonKey(PolygonKey const & in_that);
37991 
37995  PolygonKey & operator=(PolygonKey const & in_that);
37996 
38000  PolygonKey(PolygonKey && in_that);
38001 
38005  PolygonKey & operator=(PolygonKey && in_that);
38006 
38007  ~PolygonKey();
38008 
38009  static const HPS::Type staticType = HPS::Type::PolygonKey;
38010  HPS::Type ObjectType() const { return staticType; };
38011 
38012 
38015  void Consume(PolygonKit & in_kit);
38016 
38019  void Set(PolygonKit const & in_kit);
38020 
38023  void Show(PolygonKit & out_kit) const;
38024 
38027  size_t GetPointCount() const;
38028 
38032  PolygonKey & SetPoints(PointArray const & in_points);
38033 
38038  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
38039 
38043  bool ShowPoints(PointArray & out_points) const;
38044 
38050  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
38051 
38056  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
38057 
38063  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
38064 
38070  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
38071 
38076  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
38077 
38082  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
38083 
38089  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
38090 
38095  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
38096 
38104  PointArray Triangulate() const;
38105 };
38106 
38107 
38108 
38109 
38111 class HPS_API GridKit : public Kit
38112 {
38113 public:
38115  GridKit();
38116 
38119  GridKit(GridKit const & in_kit);
38120 
38123  GridKit(GridKit && in_that);
38124 
38125  virtual ~GridKit();
38126 
38127  static const HPS::Type staticType = HPS::Type::GridKit;
38128  HPS::Type ObjectType() const { return staticType; };
38129 
38132  void Consume(GridKit & in_kit);
38133 
38136  void Set(GridKit const & in_kit);
38137 
38140  void Show(GridKit & out_kit) const;
38141 
38145  GridKit & operator=(GridKit const & in_kit);
38146 
38150  GridKit & operator=(GridKit && in_that);
38151 
38154  bool Empty() const;
38155 
38159  bool Equals(GridKit const & in_kit) const;
38160 
38164  bool operator==(GridKit const & in_kit) const;
38165 
38169  bool operator!=(GridKit const & in_kit) const;
38170 
38171 
38178  GridKit & SetPriority(int in_priority);
38179 
38183  GridKit & SetType(Grid::Type in_type);
38184 
38188  GridKit & SetOrigin(Point const & in_origin);
38189 
38196  GridKit & SetFirstPoint(Point const & in_first_point);
38197 
38205  GridKit & SetSecondPoint(Point const & in_second_point);
38206 
38220  GridKit & SetFirstCount(int in_first_count);
38221 
38232  GridKit & SetSecondCount(int in_second_count);
38233 
38234 
38237  GridKit & UnsetPriority();
38238 
38241  GridKit & UnsetType();
38242 
38245  GridKit & UnsetOrigin();
38246 
38249  GridKit & UnsetFirstPoint();
38250 
38253  GridKit & UnsetSecondPoint();
38254 
38257  GridKit & UnsetFirstCount();
38258 
38261  GridKit & UnsetSecondCount();
38262 
38265  GridKit & UnsetEverything();
38266 
38267 
38271  bool ShowPriority(int & out_priority) const;
38272 
38276  bool ShowType(Grid::Type & out_type) const;
38277 
38281  bool ShowOrigin(Point & out_origin) const;
38282 
38286  bool ShowFirstPoint(Point & out_first_point) const;
38287 
38291  bool ShowSecondPoint(Point & out_second_point) const;
38292 
38296  bool ShowFirstCount(int & out_first_count) const;
38297 
38301  bool ShowSecondCount(int & out_second_count) const;
38302 
38308  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
38309 
38314  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
38315 
38320  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
38321 
38325  GridKit & UnsetUserData(intptr_t in_index);
38326 
38331  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
38332 
38336  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
38337 
38340  GridKit & UnsetAllUserData();
38341 
38343  size_t ShowUserDataCount() const;
38344 
38348  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
38349 
38354  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
38355 
38360  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
38361 };
38362 
38363 
38365 class HPS_API GridKey : public GeometryKey
38366 {
38367 public:
38369  GridKey();
38370 
38375  explicit GridKey(Key const & in_that);
38376 
38379  GridKey(GridKey const & in_that);
38380 
38383  GridKey(GridKey && in_that);
38384 
38388  GridKey & operator=(GridKey const & in_that);
38389 
38393  GridKey & operator=(GridKey && in_that);
38394 
38395  ~GridKey();
38396 
38397  static const HPS::Type staticType = HPS::Type::GridKey;
38398  HPS::Type ObjectType() const { return staticType; };
38399 
38402  void Consume(GridKit & in_kit);
38403 
38406  void Set(GridKit const & in_kit);
38407 
38410  void Show(GridKit & out_kit) const;
38411 
38412 
38416  GridKey & SetType(Grid::Type in_type);
38417 
38421  GridKey & SetOrigin(Point const & in_origin);
38422 
38429  GridKey & SetFirstPoint(Point const & in_first_point);
38430 
38438  GridKey & SetSecondPoint(Point const & in_second_point);
38439 
38453  GridKey & SetFirstCount(int in_first_count);
38454 
38465  GridKey & SetSecondCount(int in_second_count);
38466 
38467 
38468 
38472  bool ShowType(Grid::Type & out_type) const;
38473 
38477  bool ShowOrigin(Point & out_origin) const;
38478 
38482  bool ShowFirstPoint(Point & out_first_point) const;
38483 
38487  bool ShowSecondPoint(Point & out_second_point) const;
38488 
38492  bool ShowFirstCount(int & out_first_count) const;
38493 
38497  bool ShowSecondCount(int & out_second_count) const;
38498 };
38499 
38500 
38501 
38502 
38504 class HPS_API IncludeKey : public Key
38505 {
38506 public:
38508  IncludeKey();
38509 
38514  explicit IncludeKey(Key const & in_that);
38515 
38518  IncludeKey(IncludeKey const & in_that);
38519 
38523  IncludeKey & operator=(IncludeKey const & in_that);
38524 
38528  IncludeKey(IncludeKey && in_that);
38529 
38533  IncludeKey & operator=(IncludeKey && in_that);
38534 
38535  ~IncludeKey();
38536 
38537 
38538  static const HPS::Type staticType = HPS::Type::IncludeKey;
38539  HPS::Type ObjectType() const { return staticType; };
38540 
38543  SegmentKey GetTarget() const;
38544 
38545 
38550  IncludeKey & SetPriority(int in_priority);
38551 
38559  IncludeKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
38560 
38561 
38564  IncludeKey & UnsetPriority();
38565 
38568  IncludeKey & UnsetConditionalExpression();
38569 
38570 
38574  bool ShowPriority(int & out_priority) const;
38575 
38579  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
38580 
38586  IncludeKey & SetFilter(AttributeLock::Type in_type);
38587 
38594  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38595 
38601  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
38602 
38608  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
38609 
38616  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38617 
38623  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
38624 
38630  bool ShowFilter(AttributeLockTypeArray & out_types) const;
38631 
38637  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
38638 };
38639 
38640 
38641 
38643 class HPS_API StyleKey : public Key
38644 {
38645 public:
38647  StyleKey();
38648 
38653  explicit StyleKey(Key const & in_that);
38654 
38657  StyleKey(StyleKey const & in_that);
38658 
38662  StyleKey & operator=(StyleKey const & other);
38663 
38667  StyleKey(StyleKey && in_that);
38668 
38672  StyleKey & operator=(StyleKey && in_that);
38673 
38674  ~StyleKey();
38675 
38676  static const HPS::Type staticType = HPS::Type::StyleKey;
38677  HPS::Type ObjectType() const { return staticType; };
38678 
38679 
38685  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
38686 
38687 
38695  StyleKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
38696 
38697 
38700  StyleKey & UnsetConditionalExpression();
38701 
38702 
38706  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
38707 
38708 
38714  StyleKey & SetFilter(AttributeLock::Type in_type);
38715 
38722  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38723 
38729  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
38730 
38736  StyleKey & UnsetFilter(AttributeLock::Type in_type);
38737 
38744  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
38745 
38751  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
38752 
38758  bool ShowFilter(AttributeLockTypeArray & out_types) const;
38759 
38765  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
38766 };
38767 
38768 
38769 
38771 class HPS_API ReferenceKey : public GeometryKey
38772 {
38773 public:
38775  ReferenceKey();
38776 
38781  explicit ReferenceKey(Key const & in_that);
38782 
38785  ReferenceKey(ReferenceKey const & in_that);
38786 
38790  ReferenceKey & operator=(ReferenceKey const & in_that);
38791 
38795  ReferenceKey(ReferenceKey && in_that);
38796 
38800  ReferenceKey & operator=(ReferenceKey && in_that);
38801 
38802  ~ReferenceKey();
38803 
38804  static const HPS::Type staticType = HPS::Type::ReferenceKey;
38805  HPS::Type ObjectType() const { return staticType; };
38806 
38810  Key GetTarget() const;
38811 
38815  size_t ShowTargets(bool masked=true) const;
38816 
38821  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
38822 
38826  size_t ShowGeometryMask() const;
38827 
38832  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
38833 
38837  ReferenceKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
38838 
38840  ReferenceKey & UnsetMaterialMapping();
38841 
38843  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
38844 
38848  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
38849 
38852  ReferenceKey & UnsetGeometryMask();
38853 
38856  void SetModellingMatrix(MatrixKit const & in_kit);
38857 
38866  ReferenceKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
38867 
38868 
38870  void UnsetModellingMatrix();
38871 
38874  ReferenceKey & UnsetConditionalExpression();
38875 
38876 
38880  bool ShowModellingMatrix(MatrixKit & out_kit) const;
38881 
38885  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
38886 
38887 
38890  ModellingMatrixControl GetModellingMatrixControl();
38891 
38894  ModellingMatrixControl const GetModellingMatrixControl() const;
38895 };
38896 
38897 
38898 #if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
38899 
38904 class HPS_API StandAloneWindowOptionsKit : public Kit
38905 {
38906 public:
38909 
38913 
38918 
38923 
38924  virtual ~StandAloneWindowOptionsKit();
38925 
38926  static const HPS::Type staticType = HPS::Type::StandAloneWindowOptionsKit;
38927  HPS::Type ObjectType() const { return staticType; };
38928 
38932  static StandAloneWindowOptionsKit GetDefault();
38933 
38936  void Set(StandAloneWindowOptionsKit const & in_kit);
38937 
38940  void Show(StandAloneWindowOptionsKit & out_kit) const;
38941 
38945  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
38946 
38949  bool Empty() const;
38950 
38954  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
38955 
38959  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
38960 
38964  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
38965 
38969  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
38970 
38975  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
38976 
38980  StandAloneWindowOptionsKit & SetScreenAntiAliasing(bool in_state);
38981 
38985  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
38986 
38991  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
38992 
38996  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
38997 
39001  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
39002 
39007  StandAloneWindowOptionsKit & SetPreferredGPU(GPU::Preference in_gpu_preference, char const * in_gpu_name = "");
39008 
39011  StandAloneWindowOptionsKit & UnsetDriver();
39012 
39015  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
39016 
39019  StandAloneWindowOptionsKit & UnsetScreenAntiAliasing();
39020 
39023  StandAloneWindowOptionsKit & UnsetTitle();
39024 
39027  StandAloneWindowOptionsKit & UnsetSubscreen();
39028 
39031  StandAloneWindowOptionsKit & UnsetMobility();
39032 
39035  StandAloneWindowOptionsKit & UnsetFullScreen();
39036 
39039  StandAloneWindowOptionsKit & UnsetPreferredGPU();
39040 
39043  StandAloneWindowOptionsKit & UnsetEverything();
39044 
39048  bool ShowDriver(Window::Driver & out_driver) const;
39049 
39054  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39055 
39059  bool ShowTitle(UTF8 & out_window_name) const;
39060 
39064  bool ShowSubscreen(Rectangle & out_subscreen) const;
39065 
39069  bool ShowMobility(Window::Mobility & out_mobility) const;
39070 
39074  bool ShowFullScreen(bool & out_state) const;
39075 
39080  bool ShowPreferredGPU(GPU::Preference & out_gpu_preference, HPS::UTF8 & out_gpu_name) const;
39081 };
39082 #endif
39083 
39084 
39085 #if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
39086 
39094 {
39095 public:
39099 
39103 
39108 
39113 
39116 
39117  virtual HPS::Type Type() const { return ObjectType(); }
39118 
39119  static const HPS::Type staticType = HPS::Type::StandAloneWindowOptionsControl;
39120  HPS::Type ObjectType() const { return staticType; };
39121 
39126 
39131  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
39132 
39136  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
39137 
39141  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
39142 
39145  StandAloneWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
39146 
39148  StandAloneWindowOptionsControl & UnsetFallbackFonts();
39149 
39152  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
39153 
39157  bool ShowDriver(Window::Driver & out_driver) const;
39158 
39163  StandAloneWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
39164 
39168  StandAloneWindowOptionsControl & SetScreenAntiAliasing(bool in_state);
39169 
39174  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39175 
39179  bool ShowTitle(UTF8 & out_window_name) const;
39180 
39184  bool ShowSubscreen(Rectangle & out_subscreen) const;
39185 
39189  bool ShowMobility(Window::Mobility & out_mobility) const;
39190 
39194  bool ShowFullScreen(bool & out_state) const;
39195 
39199  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
39200 private:
39203 };
39204 #endif
39205 
39206 
39210 class HPS_API OffScreenWindowOptionsKit : public Kit
39211 {
39212 public:
39215 
39219 
39224 
39228  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
39229 
39230  virtual ~OffScreenWindowOptionsKit();
39231 
39232  static const HPS::Type staticType = HPS::Type::OffScreenWindowOptionsKit;
39233  HPS::Type ObjectType() const { return staticType; };
39234 
39238  static OffScreenWindowOptionsKit GetDefault();
39239 
39242  void Set(OffScreenWindowOptionsKit const & in_kit);
39243 
39246  void Show(OffScreenWindowOptionsKit & out_kit) const;
39247 
39251  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
39252 
39255  bool Empty() const;
39256 
39260  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
39261 
39265  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
39266 
39270  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
39271 
39275  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
39276 
39281  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
39282 
39286  OffScreenWindowOptionsKit & SetScreenAntiAliasing(bool in_state);
39287 
39292  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
39293 
39298  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
39299 
39304  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
39305 
39309  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
39310 
39314  OffScreenWindowOptionsKit & SetFramebufferRetention(bool in_retain);
39315 
39320  OffScreenWindowOptionsKit & SetPreferredGPU(GPU::Preference in_gpu_preference, char const * in_gpu_name = "");
39321 
39324  OffScreenWindowOptionsKit & UnsetDriver();
39325 
39328  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
39329 
39332  OffScreenWindowOptionsKit & UnsetScreenAntiAliasing();
39333 
39336  OffScreenWindowOptionsKit & UnsetHardwareResident();
39337 
39340  OffScreenWindowOptionsKit & UnsetNativeFormat();
39341 
39344  OffScreenWindowOptionsKit & UnsetOpacity();
39345 
39348  OffScreenWindowOptionsKit & UnsetFramebufferRetention();
39349 
39352  OffScreenWindowOptionsKit & UnsetPreferredGPU();
39353 
39356  OffScreenWindowOptionsKit & UnsetEverything();
39357 
39361  bool ShowDriver(Window::Driver & out_driver) const;
39362 
39367  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39368 
39372  bool ShowHardwareResident(bool & out_state) const;
39373 
39378  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
39379 
39384  bool ShowOpacity(bool & out_state, float & out_opacity) const;
39385 
39389  bool ShowFramebufferRetention(bool & out_retain) const;
39390 
39395  bool ShowPreferredGPU(GPU::Preference & out_gpu_preference, HPS::UTF8 & out_gpu_name) const;
39396 };
39397 
39401 class HPS_API ApplicationWindowOptionsKit : public Kit
39402 {
39403 public:
39406 
39410 
39415 
39420 
39421  virtual ~ApplicationWindowOptionsKit();
39422 
39423  static const HPS::Type staticType = HPS::Type::ApplicationWindowOptionsKit;
39424  HPS::Type ObjectType() const { return staticType; };
39425 
39429  static ApplicationWindowOptionsKit GetDefault();
39430 
39433  void Set(ApplicationWindowOptionsKit const & in_kit);
39434 
39437  void Show(ApplicationWindowOptionsKit & out_kit) const;
39438 
39442  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
39443 
39446  bool Empty() const;
39447 
39451  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
39452 
39456  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
39457 
39461  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
39462 
39466  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
39467 
39472  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
39473 
39477  ApplicationWindowOptionsKit & SetScreenAntiAliasing(bool in_state);
39478 
39482  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
39483 
39487  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
39488 
39493  ApplicationWindowOptionsKit & SetPreferredGPU(GPU::Preference in_gpu_preference, char const * in_gpu_name = "");
39494 
39497  ApplicationWindowOptionsKit & UnsetDriver();
39498 
39501  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
39502 
39505  ApplicationWindowOptionsKit & UnsetScreenAntiAliasing();
39506 
39509  ApplicationWindowOptionsKit & UnsetPlatformData();
39510 
39513  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
39514 
39517  ApplicationWindowOptionsKit & UnsetPreferredGPU();
39518 
39521  ApplicationWindowOptionsKit & UnsetEverything();
39522 
39526  bool ShowDriver(Window::Driver & out_driver) const;
39527 
39532  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39533 
39537  bool ShowPlatformData(PlatformData & out_platform_data) const;
39538 
39542  bool ShowFramebufferRetention(bool & out_retain) const;
39543 
39548  bool ShowPreferredGPU(GPU::Preference & out_gpu_preference, HPS::UTF8 & out_gpu_name) const;
39549 
39550 };
39551 
39552 
39553 
39556 {
39557 public:
39561 
39565 
39570 
39575 
39578 
39579  virtual HPS::Type Type() const { return ObjectType(); }
39580 
39581  static const HPS::Type staticType = HPS::Type::ApplicationWindowOptionsControl;
39582  HPS::Type ObjectType() const { return staticType; };
39583 
39588 
39591  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
39592 
39597  ApplicationWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
39598 
39602  ApplicationWindowOptionsControl & SetScreenAntiAliasing(bool in_state);
39603 
39608  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
39609 
39613  bool ShowDriver(Window::Driver & out_driver) const;
39614 
39618  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
39619 
39623  bool ShowPlatformData(PlatformData & out_platform_data) const;
39624 
39628  bool ShowFramebufferRetention(bool & out_retain) const;
39629 
39633  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
39634 
39638  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
39639 
39642  ApplicationWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
39643 
39645  ApplicationWindowOptionsControl & UnsetFallbackFonts();
39646 
39647 private:
39650 };
39651 
39652 
39653 #if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
39654 
39658 class HPS_API StandAloneWindowKey : public WindowKey
39659 {
39660 public:
39663 
39668  StandAloneWindowKey(Key const & in_key);
39669 
39672  StandAloneWindowKey(StandAloneWindowKey const & in_that);
39673 
39678 
39682  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
39683 
39685 
39686  static const HPS::Type staticType = HPS::Type::StandAloneWindowKey;
39687  HPS::Type ObjectType() const { return staticType; };
39688 
39691  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
39692 
39695  StandAloneWindowOptionsControl GetWindowOptionsControl();
39696 
39700  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
39701 
39704  Window::UpdateStatus Pause();
39705 };
39706 #endif
39707 
39709 class HPS_API ApplicationWindowKey : public WindowKey
39710 {
39711 public:
39714 
39719  ApplicationWindowKey(Key const & in_key);
39720 
39723  ApplicationWindowKey(ApplicationWindowKey const & in_that);
39724 
39729 
39733  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
39734 
39736 
39737  static const HPS::Type staticType = HPS::Type::ApplicationWindowKey;
39738  HPS::Type ObjectType() const { return staticType; };
39739 
39742  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
39743 
39746  ApplicationWindowOptionsControl GetWindowOptionsControl();
39747 
39751  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
39752 };
39753 
39757 
39758 
39759 
39761 class HPS_API GlyphElement : public Object
39762 {
39763 public:
39765  GlyphElement();
39766 
39769  GlyphElement(GlyphElement const & in_that);
39770 
39774  GlyphElement(GlyphElement && in_that);
39775 
39779  GlyphElement & operator=(GlyphElement && in_that);
39780 
39781  virtual ~GlyphElement();
39782 
39783  static const HPS::Type staticType = HPS::Type::GlyphElement;
39784  HPS::Type ObjectType() const { return staticType; };
39785 
39788  void Set(GlyphElement const & in_that);
39789 
39793  GlyphElement & operator=(GlyphElement const & in_that);
39794 
39798  bool Equals(GlyphElement const & in_that) const;
39799 
39803  bool operator==(GlyphElement const & in_that) const;
39804 
39808  bool operator!=(GlyphElement const & in_that) const;
39809 
39812  void SetFill(Glyph::Fill in_fill);
39813 
39816  void SetIndexedColor(byte in_index);
39817 
39819  void SetNormalColor();
39820 
39823  void SetExplicitColor(RGBAColor const & in_color);
39824 
39828  bool ShowFill(Glyph::Fill & out_fill) const;
39829 
39835  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
39836 };
39837 
39838 
39840 class HPS_API LineGlyphElement : public GlyphElement
39841 {
39842 public:
39844  LineGlyphElement();
39845 
39850  LineGlyphElement(GlyphElement const & in_that);
39851 
39854  LineGlyphElement(LineGlyphElement const & in_that);
39855 
39858  explicit LineGlyphElement(GlyphPointArray const & in_points);
39859 
39863  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
39864 
39868  LineGlyphElement(LineGlyphElement && in_that);
39869 
39873  LineGlyphElement & operator=(LineGlyphElement && in_that);
39874 
39875  ~LineGlyphElement();
39876 
39877  static const HPS::Type staticType = HPS::Type::LineGlyphElement;
39878  HPS::Type ObjectType() const { return staticType; };
39879 
39882  void SetPoints(GlyphPointArray const & in_points);
39883 
39887  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
39888 
39892  bool ShowPoints(GlyphPointArray & out_points) const;
39893 };
39894 
39895 
39897 class HPS_API ImageGlyphElement : public GlyphElement
39898 {
39899 public:
39902 
39907  ImageGlyphElement(GlyphElement const & in_that);
39908 
39911  ImageGlyphElement(ImageGlyphElement const & in_that);
39912 
39917 
39921  ImageGlyphElement & operator=(ImageGlyphElement && in_that);
39922 
39923  ~ImageGlyphElement();
39924 
39925  static const HPS::Type staticType = HPS::Type::ImageGlyphElement;
39926  HPS::Type ObjectType() const { return staticType; };
39927 
39928 
39932  void SetSource(char const * in_name);
39933 
39938  void SetScaling(float in_x_scale, float in_y_scale);
39939 
39946  void SetOffset(float in_x_offset, float in_y_offset);
39947 
39951  void SetRotation(float in_rotation);
39952 
39956  void SetDecimationFilter(bool in_filter);
39957 
39961  void SetInterpolationFilter(bool in_filter);
39962 
39966  void SetFixedScaling(bool in_fixed_scale);
39967 
39971  void SetFixedColoring(bool in_fixed_color);
39972 
39976  bool ShowSource(UTF8 & out_name) const;
39977 
39982  bool ShowScaling(float & out_x_scale, float & out_y_scale) const;
39983 
39988  bool ShowOffset(float & out_x_offset, float & out_y_offset) const;
39989 
39993  bool ShowRotation(float & out_rotation) const;
39994 
39998  bool ShowDecimationFilter(bool & out_filter) const;
39999 
40003  bool ShowInterpolationFilter(bool & out_filter) const;
40004 
40008  bool ShowFixedScaling(bool & out_fixed_scale) const;
40009 
40013  bool ShowFixedColoring(bool & out_fixed_color) const;
40014 
40015 };
40016 
40017 
40019 class HPS_API DotGlyphElement : public GlyphElement
40020 {
40021 public:
40023  DotGlyphElement();
40024 
40029  DotGlyphElement(GlyphElement const & in_that);
40030 
40033  DotGlyphElement(DotGlyphElement const & in_that);
40034 
40037  explicit DotGlyphElement(GlyphPoint const & in_point);
40038 
40042  DotGlyphElement(DotGlyphElement && in_that);
40043 
40047  DotGlyphElement & operator=(DotGlyphElement && in_that);
40048 
40049  ~DotGlyphElement();
40050 
40051  static const HPS::Type staticType = HPS::Type::DotGlyphElement;
40052  HPS::Type ObjectType() const { return staticType; };
40053 
40056  void SetPoint(GlyphPoint const & in_point);
40057 
40061  bool ShowPoint(GlyphPoint & out_point) const;
40062 };
40063 
40064 
40066 class HPS_API EllipseGlyphElement : public GlyphElement
40067 {
40068 public:
40071 
40076  EllipseGlyphElement(GlyphElement const & in_that);
40077 
40080  EllipseGlyphElement(EllipseGlyphElement const & in_that);
40081 
40085  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
40086 
40091 
40095  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
40096 
40098 
40099  static const HPS::Type staticType = HPS::Type::EllipseGlyphElement;
40100  HPS::Type ObjectType() const { return staticType; };
40101 
40104  void SetLowerLeft(GlyphPoint const & in_point);
40105 
40108  void SetUpperRight(GlyphPoint const & in_point);
40109 
40113  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
40114 
40118  bool ShowLowerLeft(GlyphPoint & out_point) const;
40119 
40123  bool ShowUpperRight(GlyphPoint & out_point) const;
40124 };
40125 
40127 class HPS_API SphereGlyphElement : public GlyphElement
40128 {
40129 public:
40132 
40137  SphereGlyphElement(GlyphElement const & in_that);
40138 
40141  SphereGlyphElement(SphereGlyphElement const & in_that);
40142 
40147 
40151  SphereGlyphElement & operator=(SphereGlyphElement && in_that);
40152 
40153  ~SphereGlyphElement();
40154 
40155  static const HPS::Type staticType = HPS::Type::SphereGlyphElement;
40156  HPS::Type ObjectType() const { return staticType; };
40157 };
40158 
40159 
40162 {
40163 public:
40166 
40171  CircularArcGlyphElement(GlyphElement const & in_that);
40172 
40176 
40181  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
40182 
40187 
40191  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
40192 
40194 
40195  static const HPS::Type staticType = HPS::Type::CircularArcGlyphElement;
40196  HPS::Type ObjectType() const { return staticType; };
40197 
40200  void SetStartPoint(GlyphPoint const & in_point);
40201 
40204  void SetIntermediatePoint(GlyphPoint const & in_point);
40205 
40208  void SetEndPoint(GlyphPoint const & in_point);
40209 
40214  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
40215 
40219  bool ShowStartPoint(GlyphPoint & out_point) const;
40220 
40224  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
40225 
40229  bool ShowEndPoint(GlyphPoint & out_point) const;
40230 };
40231 
40232 
40233 
40236 {
40237 public:
40240 
40245  InfiniteLineGlyphElement(GlyphElement const & in_that);
40246 
40250 
40255  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
40256 
40261 
40265  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
40266 
40268 
40269  static const HPS::Type staticType = HPS::Type::InfiniteLineGlyphElement;
40270  HPS::Type ObjectType() const { return staticType; };
40271 
40274  void SetFirstPoint(GlyphPoint const & in_point);
40275 
40278  void SetSecondPoint(GlyphPoint const & in_point);
40279 
40283  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
40284 
40287  void SetInfiniteType(InfiniteLine::Type in_type);
40288 
40292  bool ShowFirstPoint(GlyphPoint & out_point) const;
40293 
40297  bool ShowSecondPoint(GlyphPoint & out_point) const;
40298 
40302  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
40303 };
40304 
40305 
40306 
40308 class HPS_API GlyphKit : public Kit
40309 {
40310 public:
40312  GlyphKit();
40313 
40316  GlyphKit(GlyphKit const & in_kit);
40317 
40321  GlyphKit(GlyphKit && in_that);
40322 
40326  GlyphKit & operator=(GlyphKit && in_that);
40327 
40328  virtual ~GlyphKit();
40329 
40330  static const HPS::Type staticType = HPS::Type::GlyphKit;
40331  HPS::Type ObjectType() const { return staticType; };
40332 
40336  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
40337 
40340  void Set(GlyphKit const & in_kit);
40341 
40344  void Show(GlyphKit & out_kit) const;
40345 
40349  GlyphKit & operator=(GlyphKit const & in_kit);
40350 
40353  bool Empty() const;
40354 
40358  bool Equals(GlyphKit const & in_kit) const;
40359 
40363  bool operator==(GlyphKit const & in_kit) const;
40364 
40368  bool operator!=(GlyphKit const & in_kit) const;
40369 
40373  GlyphKit & SetRadius(sbyte in_radius);
40374 
40379  GlyphKit & SetOffset(GlyphPoint const & in_point);
40380 
40385  GlyphKit & SetOrdered(bool in_ordered);
40386 
40390  GlyphKit & SetElements(GlyphElementArray const & in_def);
40391 
40396  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
40397 
40401  GlyphKit & SetElement(GlyphElement const & in_element);
40402 
40405  GlyphKit & UnsetRadius();
40406 
40409  GlyphKit & UnsetOffset();
40410 
40413  GlyphKit & UnsetOrdered();
40414 
40417  GlyphKit & UnsetElements();
40418 
40421  GlyphKit & UnsetEverything();
40422 
40426  bool ShowRadius(sbyte & out_radius) const;
40427 
40431  bool ShowOffset(GlyphPoint & out_point) const;
40432 
40436  bool ShowOrdered(bool & out_ordered) const;
40437 
40441  bool ShowElements(GlyphElementArray & out_def) const;
40442 };
40443 
40447 
40448 
40451 class HPS_API LinePatternOptionsKit : public Kit
40452 {
40453 public:
40456 
40460 
40465 
40469  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
40470 
40471  virtual ~LinePatternOptionsKit();
40472 
40473  static const HPS::Type staticType = HPS::Type::LinePatternOptionsKit;
40474  HPS::Type ObjectType() const { return staticType; };
40475 
40478  void Set(LinePatternOptionsKit const & in_kit);
40479 
40482  void Show(LinePatternOptionsKit & out_kit) const;
40483 
40487  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
40488 
40491  bool Empty() const;
40492 
40496  bool Equals(LinePatternOptionsKit const & in_kit) const;
40497 
40501  bool operator==(LinePatternOptionsKit const & in_kit) const;
40502 
40506  bool operator!=(LinePatternOptionsKit const & in_kit) const;
40507 
40511  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
40512 
40516  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
40517 
40521  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
40522 
40526  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
40527 
40531  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
40532 
40536  LinePatternOptionsKit & SetJoin(char const * in_glyph);
40537 
40541  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
40542 
40546  LinePatternOptionsKit & UnsetStartCap();
40547 
40551  LinePatternOptionsKit & UnsetEndCap();
40552 
40555  LinePatternOptionsKit & UnsetInnerCap();
40556 
40560  LinePatternOptionsKit & UnsetJoin();
40561 
40564  LinePatternOptionsKit & UnsetEverything();
40565 
40571  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
40572 
40578  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
40579 
40583  bool ShowInnerCap(LinePattern::Cap & out_type) const;
40584 
40590  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
40591 };
40592 
40595 class HPS_API LinePatternElement : public Object
40596 {
40597 public:
40600 
40603  LinePatternElement(LinePatternElement const & in_that);
40604 
40609 
40613  LinePatternElement & operator=(LinePatternElement && in_that);
40614 
40615  ~LinePatternElement();
40616 
40617  static const HPS::Type staticType = HPS::Type::LinePatternElement;
40618  HPS::Type ObjectType() const { return staticType; };
40619 
40622  void Set(LinePatternElement const & in_that);
40623 
40627  LinePatternElement & operator=(LinePatternElement const & in_that);
40628 
40632  bool Equals(LinePatternElement const & in_that) const;
40633 
40637  bool operator==(LinePatternElement const & in_that) const;
40638 
40642  bool operator!=(LinePatternElement const & in_that) const;
40643 
40647  void SetSize(float in_size, LinePattern::SizeUnits in_units);
40648 
40653  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
40654 };
40655 
40658 {
40659 public:
40662 
40668 
40672 
40676  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
40677 
40682 
40686  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
40687 
40689 
40690  static const HPS::Type staticType = HPS::Type::SolidLinePatternElement;
40691  HPS::Type ObjectType() const { return staticType; };
40692 
40696  void SetColor(RGBAColor const & in_color);
40697 
40701  void SetMaterialByIndex(float in_material_index);
40702 
40708  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
40709 };
40710 
40711 
40714 {
40715 public:
40718 
40724 
40728 
40732  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
40733 
40738 
40742  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
40743 
40745 
40746  static const HPS::Type staticType = HPS::Type::BlankLinePatternElement;
40747  HPS::Type ObjectType() const { return staticType; };
40748 };
40749 
40750 
40753 {
40754 public:
40757 
40763 
40767 
40771  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
40772 
40777 
40781  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
40782 
40784 
40785  static const HPS::Type staticType = HPS::Type::GlyphLinePatternElement;
40786  HPS::Type ObjectType() const { return staticType; };
40787 
40790  void SetSource(char const * in_source);
40791 
40795  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
40796 
40799  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
40800 
40803  void SetMirror(bool in_state);
40804 
40807  void SetFixed(bool in_state);
40808 
40811  void SetRotation(float in_degrees);
40812 
40816  bool ShowSource(UTF8 & out_source) const;
40817 
40822  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
40823 
40827  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
40828 
40832  bool ShowMirror(bool & out_state) const;
40833 
40837  bool ShowFixed(bool & out_state) const;
40838 
40842  bool ShowRotation(float & out_degrees) const;
40843 };
40844 
40846 class HPS_API LinePatternParallelKit : public Kit
40847 {
40848 public:
40851 
40855 
40860 
40864  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
40865 
40866  virtual ~LinePatternParallelKit();
40867 
40868  static const HPS::Type staticType = HPS::Type::LinePatternParallelKit;
40869  HPS::Type ObjectType() const { return staticType; };
40870 
40873  void Set(LinePatternParallelKit const & in_kit);
40874 
40877  void Show(LinePatternParallelKit & out_kit) const;
40878 
40882  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
40883 
40886  bool Empty() const;
40887 
40891  bool Equals(LinePatternParallelKit const & in_kit) const;
40892 
40896  bool operator==(LinePatternParallelKit const & in_kit) const;
40897 
40901  bool operator!=(LinePatternParallelKit const & in_kit) const;
40902 
40906  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
40907 
40911  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
40912 
40916  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
40917 
40921  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
40922 
40927  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
40928 
40932  LinePatternParallelKit & SetBody(LinePatternElement const & in_element);
40933 
40937  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
40938 
40942  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
40943 
40947  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
40948 
40955  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
40956 
40962  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
40963 
40967  LinePatternParallelKit & SetContinuous(bool in_state);
40968 
40971  LinePatternParallelKit & UnsetStartCap();
40972 
40975  LinePatternParallelKit & UnsetEndCap();
40976 
40979  LinePatternParallelKit & UnsetJoin();
40980 
40983  LinePatternParallelKit & UnsetBody();
40984 
40987  LinePatternParallelKit & UnsetAbsoluteLength();
40988 
40991  LinePatternParallelKit & UnsetAbsoluteWeight();
40992 
40995  LinePatternParallelKit & UnsetJustification();
40996 
40999  LinePatternParallelKit & UnsetOffset();
41000 
41003  LinePatternParallelKit & UnsetWeight();
41004 
41007  LinePatternParallelKit & UnsetContinuous();
41008 
41011  LinePatternParallelKit & UnsetEverything();
41012 
41016  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
41017 
41021  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
41022 
41026  bool ShowJoin(GlyphLinePatternElement & out_join) const;
41027 
41031  bool ShowBody(LinePatternElementArray & out_elements) const;
41032 
41036  bool ShowAbsoluteLength(bool & out_state) const;
41037 
41041  bool ShowAbsoluteWeight(bool & out_state) const;
41042 
41046  bool ShowJustification(LinePattern::Justification & out_type) const;
41047 
41053  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
41054 
41060  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
41061 
41065  bool ShowContinuous(bool & out_state) const;
41066 };
41067 
41068 
41070 class HPS_API LinePatternKit : public Kit
41071 {
41072 public:
41074  LinePatternKit();
41075 
41078  LinePatternKit(LinePatternKit const & in_kit);
41079 
41083  LinePatternKit(LinePatternKit && in_that);
41084 
41088  LinePatternKit & operator=(LinePatternKit && in_that);
41089 
41090  virtual ~LinePatternKit();
41091 
41092  static const HPS::Type staticType = HPS::Type::LinePatternKit;
41093  HPS::Type ObjectType() const { return staticType; };
41094 
41098  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
41099 
41102  void Set(LinePatternKit const & in_kit);
41103 
41106  void Show(LinePatternKit & out_kit) const;
41107 
41111  LinePatternKit & operator=(LinePatternKit const & in_kit);
41112 
41115  bool Empty() const;
41116 
41120  bool Equals(LinePatternKit const & in_kit) const;
41121 
41125  bool operator==(LinePatternKit const & in_kit) const;
41126 
41130  bool operator!=(LinePatternKit const & in_kit) const;
41131 
41135  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
41136 
41141  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
41142 
41146  LinePatternKit & SetParallel(LinePatternParallelKit const & in_parallel);
41147 
41151  LinePatternKit & SetJoin(LinePattern::Join in_type);
41152 
41155  LinePatternKit & UnsetParallels();
41156 
41159  LinePatternKit & UnsetJoin();
41160 
41163  LinePatternKit & UnsetEverything();
41164 
41168  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
41169 
41173  bool ShowJoin(LinePattern::Join & out_type) const;
41174 };
41175 
41176 
41180 
41182 class HPS_API ShapeElement : public Object
41183 {
41184 public:
41186  ShapeElement();
41187 
41190  ShapeElement(ShapeElement const & in_that);
41191 
41195  ShapeElement(ShapeElement && in_that);
41196 
41200  ShapeElement & operator=(ShapeElement && in_that);
41201 
41202  virtual ~ShapeElement();
41203 
41204  static const HPS::Type staticType = HPS::Type::ShapeElement;
41205  HPS::Type ObjectType() const { return staticType; };
41206 
41209  void Set(ShapeElement const & in_that);
41210 
41214  ShapeElement & operator=(ShapeElement const & in_that);
41215 
41219  bool Equals(ShapeElement const & in_that) const;
41220 
41224  bool operator==(ShapeElement const & in_that) const;
41225 
41229  bool operator!=(ShapeElement const & in_that) const;
41230 
41235  ShapeElement & SetDisjointed(bool in_state);
41236 
41242  bool ShowDisjointed(bool & out_state) const;
41243 
41247  ShapeElement & SetFill(bool in_state);
41248 
41253  bool ShowFill(bool & out_state) const;
41254 };
41255 
41257 class HPS_API PolygonShapeElement : public ShapeElement
41258 {
41259 public:
41262 
41267  PolygonShapeElement(ShapeElement const & in_that);
41268 
41271  PolygonShapeElement(PolygonShapeElement const & in_that);
41272 
41275  explicit PolygonShapeElement(ShapePointArray const & in_points);
41276 
41280  PolygonShapeElement(size_t in_count, ShapePoint const in_points[]);
41281 
41286 
41290  PolygonShapeElement & operator=(PolygonShapeElement && in_that);
41291 
41293 
41294  static const HPS::Type staticType = HPS::Type::PolygonShapeElement;
41295  HPS::Type ObjectType() const { return staticType; };
41296 
41299  PolygonShapeElement & SetPoints(ShapePointArray const & in_points);
41300 
41304  PolygonShapeElement & SetPoints(size_t in_count, ShapePoint const in_points[]);
41305 
41309  bool ShowPoints(ShapePointArray & out_points) const;
41310 };
41311 
41313 class HPS_API EllipseShapeElement : public ShapeElement
41314 {
41315 public:
41318 
41323  EllipseShapeElement(ShapeElement const & in_that);
41324 
41327  EllipseShapeElement(EllipseShapeElement const & in_that);
41328 
41333  explicit EllipseShapeElement(ShapePoint const & in_center, ShapePoint const & in_major_axis_point, ShapePoint const & in_minor_axis_point);
41334 
41339 
41343  EllipseShapeElement & operator=(EllipseShapeElement && in_that);
41344 
41346 
41347  static const HPS::Type staticType = HPS::Type::EllipseShapeElement;
41348  HPS::Type ObjectType() const { return staticType; };
41349 
41352  EllipseShapeElement & SetCenter(ShapePoint const & in_center);
41353 
41357  bool ShowCenter(ShapePoint & out_center) const;
41358 
41361  EllipseShapeElement & SetMinorAxisPoint(ShapePoint const & in_minor_axis_point);
41362 
41366  bool ShowMinorAxisPoint(ShapePoint & out_minor_axis_point) const;
41367 
41370  EllipseShapeElement & SetMajorAxisPoint(ShapePoint const & in_major_axis_point);
41371 
41375  bool ShowMajorAxisPoint(ShapePoint & out_major_axis_point) const;
41376 };
41377 
41379 class HPS_API CircleShapeElement : public ShapeElement
41380 {
41381 public:
41384 
41389  CircleShapeElement(ShapeElement const & in_that);
41390 
41393  CircleShapeElement(CircleShapeElement const & in_that);
41394 
41398  explicit CircleShapeElement(ShapePoint const & in_center, ShapePoint const & in_radius);
41399 
41404 
41408  CircleShapeElement & operator=(CircleShapeElement && in_that);
41409 
41410  ~CircleShapeElement();
41411 
41412  static const HPS::Type staticType = HPS::Type::CircleShapeElement;
41413  HPS::Type ObjectType() const { return staticType; };
41414 
41417  CircleShapeElement & SetCenter(ShapePoint const & in_center);
41418 
41422  bool ShowCenter(ShapePoint & out_center) const;
41423 
41426  CircleShapeElement & SetRadius(ShapePoint const & in_radius);
41427 
41431  bool ShowRadius(ShapePoint & out_radius) const;
41432 };
41433 
41436 {
41437 public:
41440 
41445  EllipticalArcShapeElement(ShapeElement const & in_that);
41446 
41450 
41457  explicit EllipticalArcShapeElement(ShapePoint const & in_center, ShapePoint const & in_major_axis_point, ShapePoint const & in_minor_axis_point, float in_start = 0.0f, float in_end = 360.0f);
41458 
41463 
41467  EllipticalArcShapeElement & operator=(EllipticalArcShapeElement && in_that);
41468 
41470 
41471  static const HPS::Type staticType = HPS::Type::EllipticalArcShapeElement;
41472  HPS::Type ObjectType() const { return staticType; };
41473 
41476  EllipticalArcShapeElement & SetCenter(ShapePoint const & in_center);
41477 
41481  bool ShowCenter(ShapePoint & out_center) const;
41482 
41485  EllipticalArcShapeElement & SetMinorAxisPoint(ShapePoint const & in_minor_axis_point);
41486 
41490  bool ShowMinorAxisPoint(ShapePoint & out_minor_axis_point) const;
41491 
41494  EllipticalArcShapeElement & SetMajorAxisPoint(ShapePoint const & in_major_axis_point);
41495 
41499  bool ShowMajorAxisPoint(ShapePoint & out_major_axis_point) const;
41500 
41503  EllipticalArcShapeElement & SetStart(float in_start);
41504 
41508  bool ShowStart(float & out_start) const;
41509 
41512  EllipticalArcShapeElement & SetEnd(float in_end);
41513 
41517  bool ShowEnd(float & out_end) const;
41518 };
41519 
41522 {
41523 public:
41526 
41531  CircularArcShapeElement(ShapeElement const & in_that);
41532 
41536 
41541  explicit CircularArcShapeElement(ShapePoint const & in_start_point, ShapePoint const & in_middle_point, ShapePoint const & in_end_point);
41542 
41547 
41551  CircularArcShapeElement & operator=(CircularArcShapeElement && in_that);
41552 
41554 
41555  static const HPS::Type staticType = HPS::Type::CircularArcShapeElement;
41556  HPS::Type ObjectType() const { return staticType; };
41557 
41560  CircularArcShapeElement & SetStartPoint(ShapePoint const & in_start);
41561 
41565  bool ShowStartPoint(ShapePoint & out_start) const;
41566 
41569  CircularArcShapeElement & SetMiddlePoint(ShapePoint const & in_middle);
41570 
41574  bool ShowMiddlePoint(ShapePoint & out_middle) const;
41575 
41578  CircularArcShapeElement & SetEndPoint(ShapePoint const & in_end);
41579 
41583  bool ShowEndPoint(ShapePoint & out_end) const;
41584 };
41585 
41590 {
41591 public:
41594 
41599  LeaderLineClippingElement(ShapeElement const & in_that);
41600 
41604 
41609 
41613  LeaderLineClippingElement & operator=(LeaderLineClippingElement && in_that);
41614 
41616 
41617  static const HPS::Type staticType = HPS::Type::LeaderLineClippingElement;
41618  HPS::Type ObjectType() const { return staticType; };
41619 
41620  bool ShowClipShapeType(HPS::Type& out_type);
41621 
41625  bool ShowShape(PolygonShapeElement& out_shape) const;
41626 
41630  bool ShowShape(EllipseShapeElement& out_shape) const;
41631 
41635  bool ShowShape(EllipticalArcShapeElement& out_shape) const;
41636 
41640  bool ShowShape(CircleShapeElement& out_shape) const;
41641 
41645  bool ShowShape(CircularArcShapeElement& out_shape) const;
41646 
41649  LeaderLineClippingElement & SetShape(const PolygonShapeElement & in_shape);
41650 
41653  LeaderLineClippingElement & SetShape(const EllipseShapeElement& in_shape);
41654 
41657  LeaderLineClippingElement & SetShape(const EllipticalArcShapeElement & in_shape);
41658 
41661  LeaderLineClippingElement & SetShape(const CircleShapeElement & in_shape);
41662 
41665  LeaderLineClippingElement & SetShape(const CircularArcShapeElement & in_shape);
41666 
41668  LeaderLineClippingElement & UnSetShape();
41669 };
41670 
41675 class HPS_API AnchorShapeElement : public ShapeElement
41676 {
41677 public:
41680 
41685  AnchorShapeElement(ShapeElement const & in_that);
41686 
41689  AnchorShapeElement(AnchorShapeElement const & in_that);
41690 
41693  explicit AnchorShapeElement(ShapePoint const & in_anchor_point);
41694 
41699  explicit AnchorShapeElement(ShapePoint const & in_anchor_point, ShapePointArray const & in_intermediate_points, bool in_connection);
41700 
41705 
41709  AnchorShapeElement & operator=(AnchorShapeElement && in_that);
41710 
41711  ~AnchorShapeElement();
41712 
41713  static const HPS::Type staticType = HPS::Type::AnchorShapeElement;
41714  HPS::Type ObjectType() const { return staticType; };
41715 
41718  AnchorShapeElement & SetAnchor(ShapePoint const & in_anchor);
41719 
41723  bool ShowAnchor(ShapePoint & out_anchor) const;
41724 
41727  AnchorShapeElement & SetIntermediatePoints(ShapePointArray const & in_intermediate_points);
41728 
41732  bool ShowIntermediatePoints(ShapePointArray & out_intermediate_points) const;
41733 
41735  AnchorShapeElement & UnsetIntermediatePoints();
41736 
41739  AnchorShapeElement & SetConnection(bool in_connection);
41740 
41744  bool ShowConnection(bool & out_connection) const;
41745 
41747  AnchorShapeElement & UnsetConnection();
41748 };
41749 
41750 
41752 class HPS_API LineShapeElement : public ShapeElement
41753 {
41754 public:
41756  LineShapeElement();
41757 
41762  LineShapeElement(ShapeElement const & in_that);
41763 
41766  LineShapeElement(LineShapeElement const & in_that);
41767 
41770  explicit LineShapeElement(ShapePointArray const & in_points);
41771 
41775  LineShapeElement(size_t in_count, ShapePoint const in_points []);
41776 
41780  LineShapeElement(ShapePoint const & in_start, ShapePoint const & in_end);
41781 
41785  LineShapeElement(LineShapeElement && in_that);
41786 
41790  LineShapeElement & operator=(LineShapeElement && in_that);
41791 
41792  ~LineShapeElement();
41793 
41794  static const HPS::Type staticType = HPS::Type::LineShapeElement;
41795  HPS::Type ObjectType() const { return staticType; };
41796 
41799  LineShapeElement & SetPoints(ShapePointArray const & in_points);
41800 
41804  LineShapeElement & SetPoints(size_t in_count, ShapePoint const in_points []);
41805 
41809  bool ShowPoints(ShapePointArray & out_points) const;
41810 };
41811 
41815 
41816 
41818 class HPS_API Definition : public Object
41819 {
41820 public:
41822  Definition();
41823 
41826  Definition(Definition const & in_that);
41827 
41831  Definition & operator=(Definition const & in_that);
41832 
41836  Definition(Definition && in_that);
41837 
41841  Definition & operator=(Definition && in_that);
41842 
41843  virtual ~Definition();
41844 
41845  static const HPS::Type staticType = HPS::Type::Definition;
41846  HPS::Type ObjectType() const { return staticType; };
41847 
41849  void Undefine();
41850 
41853  PortfolioKey Owner() const;
41854 
41857  UTF8 Name() const;
41858 
41861  virtual void Assign(Definition const & in_that);
41862 
41866  bool Equals(Definition const & in_that) const;
41867 
41871  bool operator==(Definition const & in_that) const;
41872 
41876  bool operator!=(Definition const & in_that) const;
41877 };
41878 
41879 
41882 class HPS_API PortfolioKey : public Key
41883 {
41884 public:
41886  PortfolioKey();
41887 
41892  explicit PortfolioKey(Key const & in_that);
41893 
41896  PortfolioKey(PortfolioKey const & in_that);
41897 
41901  PortfolioKey & operator=(PortfolioKey const & in_that);
41902 
41906  PortfolioKey(PortfolioKey && in_that);
41907 
41911  PortfolioKey & operator=(PortfolioKey && in_that);
41912 
41913  ~PortfolioKey();
41914 
41915  static const HPS::Type staticType = HPS::Type::PortfolioKey;
41916  HPS::Type ObjectType() const { return staticType; };
41917 
41918  // Define
41919 
41926  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
41927 
41935  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
41936 
41937 
41949  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
41950  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
41951  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
41952 
41965  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
41966  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
41967  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
41968 
41969 
41975  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
41976 
41977 
41983  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
41984 
41985 
41991  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
41992 
41999  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
42000 
42001 
42007  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
42008 
42009 
42015  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
42016 
42017 
42023  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
42024 
42030  ShapeDefinition DefineShape(char const * in_name, ShapeKit const & in_source);
42031 
42032  // UnDefine
42033 
42037  PortfolioKey & UndefineTexture(char const * in_name);
42038 
42042  PortfolioKey & UndefineCubeMap(char const * in_name);
42043 
42047  PortfolioKey & UndefineImage(char const * in_name);
42048 
42052  PortfolioKey & UndefineNamedStyle(char const * in_name);
42053 
42057  PortfolioKey & UndefineMaterialPalette(char const * in_name);
42058 
42062  PortfolioKey & UndefineGlyph(char const * in_name);
42063 
42067  PortfolioKey & UndefineLinePattern(char const * in_name);
42068 
42072  PortfolioKey & UndefineShader(char const * in_name);
42073 
42077  PortfolioKey & UndefineShape(char const * in_name);
42078 
42079  // Import collections
42085  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42086 
42087 
42093  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42094 
42100  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42101 
42107  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42108 
42114  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42115 
42121  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42122 
42128  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42129 
42135  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42136 
42142  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42143 
42149  PortfolioKey & ImportAllShapes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
42150 
42151 
42152  // Import individual definitions
42156  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
42157 
42161  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
42162 
42166  ImageDefinition ImportImage(ImageDefinition const & in_definition);
42167 
42171  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
42172 
42176  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
42177 
42181  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
42182 
42186  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
42187 
42191  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
42192 
42196  ShapeDefinition ImportShape(ShapeDefinition const & in_definition);
42197 
42198 
42199  // Show
42201  size_t GetDefinitionCount() const;
42202 
42204  size_t GetTextureDefinitionCount() const;
42205 
42207  size_t GetCubeMapDefinitionCount() const;
42208 
42210  size_t GetImageDefinitionCount() const;
42211 
42213  size_t GetNamedStyleDefinitionCount() const;
42214 
42216  size_t GetMaterialPaletteDefinitionCount() const;
42217 
42219  size_t GetGlyphDefinitionCount() const;
42220 
42222  size_t GetLinePatternDefinitionCount() const;
42223 
42226  size_t GetShaderDefinitionCount() const;
42227 
42229  size_t GetShapeDefinitionCount() const;
42230 
42234  bool ShowTextureDefinition(char const * in_name) const;
42235 
42240  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
42241 
42245  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
42246 
42250  bool ShowCubeMapDefinition(char const * in_name) const;
42251 
42256  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
42257 
42261  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
42262 
42266  bool ShowImageDefinition(char const * in_name) const;
42267 
42272  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
42273 
42277  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
42278 
42282  bool ShowNamedStyleDefinition(char const * in_name) const;
42283 
42288  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
42289 
42293  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
42294 
42298  bool ShowMaterialPaletteDefinition(char const * in_name) const;
42299 
42304  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
42305 
42309  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
42310 
42314  bool ShowGlyphDefinition(char const * in_name) const;
42315 
42320  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
42321 
42325  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
42326 
42330  bool ShowLinePatternDefinition(char const * in_name) const;
42331 
42336  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
42337 
42341  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
42342 
42346  bool ShowShaderDefinition(char const * in_name) const;
42347 
42352  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
42353 
42357  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
42358 
42362  bool ShowShapeDefinition(char const * in_name) const;
42363 
42368  bool ShowShapeDefinition(char const * in_name, ShapeDefinition & out_found) const;
42369 
42373  bool ShowAllShapeDefinitions(ShapeDefinitionArray & out_definitions) const;
42374 
42375 private:
42377  void MoveTo(SegmentKey const & in_new_owner);
42378 
42380  Key CopyTo(SegmentKey const & in_destination) const;
42381 };
42382 
42383 
42384 
42386 class HPS_API GlyphDefinition : public Definition
42387 {
42388 public:
42390  GlyphDefinition();
42391 
42396  GlyphDefinition(Definition const & in_that);
42397 
42400  GlyphDefinition(GlyphDefinition const & in_that);
42401 
42405  GlyphDefinition & operator=(GlyphDefinition const & in_that);
42406 
42410  GlyphDefinition(GlyphDefinition && in_that);
42411 
42415  GlyphDefinition & operator=(GlyphDefinition && in_that);
42416 
42417  ~GlyphDefinition();
42418 
42419  static const HPS::Type staticType = HPS::Type::GlyphDefinition;
42420  HPS::Type ObjectType() const { return staticType; };
42421 
42424  void Set(GlyphKit const & in_kit);
42425 
42428  void Show(GlyphKit & out_kit) const;
42429 };
42430 
42431 
42433 class HPS_API TextureDefinition : public Definition
42434 {
42435 public:
42438 
42443  TextureDefinition(Definition const & in_that);
42444 
42447  TextureDefinition(TextureDefinition const & in_that);
42448 
42452  TextureDefinition & operator=(TextureDefinition const & in_that);
42453 
42458 
42462  TextureDefinition & operator=(TextureDefinition && in_that);
42463 
42464  ~TextureDefinition();
42465 
42466  static const HPS::Type staticType = HPS::Type::TextureDefinition;
42467  HPS::Type ObjectType() const { return staticType; };
42468 
42471  void SetSource(ImageDefinition const & in_source);
42472 
42476  bool ShowSource(ImageDefinition & out_source) const;
42477 
42483  bool ShowSource(UTF8 & out_source) const;
42484 
42487  void SetOptions(TextureOptionsKit const & in_options);
42488 
42491  void ShowOptions(TextureOptionsKit & out_options) const;
42492 
42493 };
42494 
42498 class HPS_API TextureOptionsKit : public Kit
42499 {
42500 public:
42503 
42506  TextureOptionsKit(TextureOptionsKit const & in_kit);
42507 
42512 
42516  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
42517 
42518  virtual ~TextureOptionsKit();
42519 
42520  static const HPS::Type staticType = HPS::Type::TextureOptionsKit;
42521  HPS::Type ObjectType() const { return staticType; };
42522 
42526  static TextureOptionsKit GetDefault();
42527 
42530  void Set(TextureOptionsKit const & in_kit);
42531 
42534  void Show(TextureOptionsKit & out_kit) const;
42535 
42539  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
42540 
42543  bool Empty() const;
42544 
42548  bool Equals(TextureOptionsKit const & in_kit) const;
42549 
42553  bool operator==(TextureOptionsKit const & in_kit) const;
42554 
42558  bool operator!=(TextureOptionsKit const & in_kit) const;
42559 
42564  TextureOptionsKit & SetDecal(bool in_state);
42565 
42569  TextureOptionsKit & SetDownSampling(bool in_state);
42570 
42574  TextureOptionsKit & SetModulation(bool in_state);
42575 
42579  TextureOptionsKit & SetParameterOffset(size_t in_offset);
42580 
42584  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
42585 
42589  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
42590 
42594  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
42595 
42599  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
42600 
42604  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
42605 
42610  TextureOptionsKit & SetValueScale(float in_min, float in_max);
42611 
42614  TextureOptionsKit & UnsetDecal();
42615 
42618  TextureOptionsKit & UnsetDownSampling();
42619 
42622  TextureOptionsKit & UnsetModulation();
42623 
42626  TextureOptionsKit & UnsetParameterOffset();
42627 
42630  TextureOptionsKit & UnsetParameterizationSource();
42631 
42634  TextureOptionsKit & UnsetTiling();
42635 
42638  TextureOptionsKit & UnsetInterpolationFilter();
42639 
42642  TextureOptionsKit & UnsetDecimationFilter();
42643 
42646  TextureOptionsKit & UnsetTransformMatrix();
42647 
42650  TextureOptionsKit & UnsetValueScale();
42651 
42654  TextureOptionsKit & UnsetEverything();
42655 
42659  bool ShowDecal(bool & out_state) const;
42660 
42664  bool ShowDownSampling(bool & out_state) const;
42665 
42669  bool ShowModulation(bool & out_state) const;
42670 
42674  bool ShowParameterOffset(size_t & out_offset) const;
42675 
42679  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
42680 
42684  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
42685 
42689  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
42690 
42694  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
42695 
42699  bool ShowTransformMatrix(MatrixKit & out_transform) const;
42700 
42705  bool ShowValueScale(float & out_min, float & out_max) const;
42706 };
42707 
42708 
42710 class HPS_API Image
42711 {
42712 public:
42715  enum class Format : uint32_t
42716  {
42717  RGB,
42718  RGBA,
42719  ARGB,
42720  Mapped8,
42721  Grayscale,
42722  Bmp,
42723  Jpeg,
42724  Png,
42725  Targa,
42726  DXT1,
42727  DXT3,
42728  DXT5
42729  };
42730 
42732 class HPS_API ExportOptionsKit : public Kit
42733  {
42734  public:
42736  ExportOptionsKit();
42737 
42740  ExportOptionsKit(ExportOptionsKit const & in_kit);
42741 
42745  ExportOptionsKit(ExportOptionsKit && in_that);
42746 
42750  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
42751 
42752  virtual ~ExportOptionsKit();
42753 
42754  static const HPS::Type staticType = HPS::Type::ImageExportOptionsKit;
42755  HPS::Type ObjectType() const { return staticType; };
42756 
42760  static ExportOptionsKit GetDefault();
42761 
42764  void Set(ExportOptionsKit const & in_kit);
42765 
42768  void Show(ExportOptionsKit & out_kit) const;
42769 
42773  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
42774 
42777  bool Empty() const;
42778 
42782  bool Equals(ExportOptionsKit const & in_kit) const;
42783 
42787  bool operator==(ExportOptionsKit const & in_kit) const;
42788 
42792  bool operator!=(ExportOptionsKit const & in_kit) const;
42793 
42798  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
42799 
42804  ExportOptionsKit & SetFormat(Image::Format in_format);
42805 
42810  ExportOptionsKit & SetTransparentBackground(bool in_state);
42811 
42814  ExportOptionsKit & UnsetSize();
42815 
42818  ExportOptionsKit & UnsetFormat();
42819 
42822  ExportOptionsKit & UnsetTransparentBackground();
42823 
42826  ExportOptionsKit & UnsetEverything();
42827 
42832  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
42833 
42837  bool ShowFormat(Image::Format & out_format) const;
42838 
42842  bool ShowTransparentBackground(bool & out_state) const;
42843  };
42844 
42846 class HPS_API ImportOptionsKit : public Kit
42847  {
42848  public:
42850  ImportOptionsKit();
42851 
42854  ImportOptionsKit(ImportOptionsKit const & in_kit);
42855 
42859  ImportOptionsKit(ImportOptionsKit && in_that);
42860 
42864  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42865 
42866  virtual ~ImportOptionsKit();
42867 
42868  static const HPS::Type staticType = HPS::Type::ImageImportOptionsKit;
42869  HPS::Type ObjectType() const { return staticType; };
42870 
42873  void Set(ImportOptionsKit const & in_kit);
42874 
42877  void Show(ImportOptionsKit & out_kit) const;
42878 
42882  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42883 
42886  bool Empty() const;
42887 
42891  bool Equals(ImportOptionsKit const & in_kit) const;
42892 
42896  bool operator==(ImportOptionsKit const & in_kit) const;
42897 
42901  bool operator!=(ImportOptionsKit const & in_kit) const;
42902 
42909  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
42910 
42914  ImportOptionsKit & SetFormat(Image::Format in_format);
42915 
42920  ImportOptionsKit & SetDownSampling(bool in_state);
42921 
42926  ImportOptionsKit & SetCompressionQuality(float in_quality);
42927 
42930  ImportOptionsKit & UnsetSize();
42931 
42934  ImportOptionsKit & UnsetFormat();
42935 
42938  ImportOptionsKit & UnsetDownSampling();
42939 
42942  ImportOptionsKit & UnsetCompressionQuality();
42943 
42946  ImportOptionsKit & UnsetEverything();
42947 
42952  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
42953 
42957  bool ShowFormat(Image::Format & out_format) const;
42958 
42962  bool ShowDownSampling(bool & out_state) const;
42963 
42967  bool ShowCompressionQuality(float & out_quality) const;
42968  };
42969 
42971  class HPS_API File
42972  {
42973  public:
42979  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
42980 
42987  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
42988 
42997  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, bool in_transparent_background = false);
42998 
43003  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
43004 
43005  private:
43007  File();
43008  };
43009 
43010 private:
43012  Image();
43013 };
43014 
43015 
43017 class HPS_API ImageKit : public Kit
43018 {
43019 public:
43021  ImageKit();
43022 
43025  ImageKit(ImageKit const & in_kit);
43026 
43031  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
43032 
43036  ImageKit(ImageKit && in_that);
43037 
43041  ImageKit & operator=(ImageKit && in_that);
43042 
43043  virtual ~ImageKit();
43044 
43045  static const HPS::Type staticType = HPS::Type::ImageKit;
43046  HPS::Type ObjectType() const { return staticType; };
43047 
43050  void Set(ImageKit const & in_kit);
43051 
43054  void Show(ImageKit & out_kit) const;
43055 
43059  ImageKit & operator=(ImageKit const & in_kit);
43060 
43063  bool Empty() const;
43064 
43068  bool Equals(ImageKit const & in_kit) const;
43069 
43073  bool operator==(ImageKit const & in_kit) const;
43074 
43078  bool operator!=(ImageKit const & in_kit) const;
43079 
43083  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
43084 
43087  void Convert(HPS::Image::Format in_format);
43088 
43093  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
43094 
43098  ImageKit & SetData(ByteArray const & in_image_data);
43099 
43104  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
43105 
43109  ImageKit & SetFormat(Image::Format in_format);
43110 
43114  ImageKit & SetDownSampling(bool in_state);
43115 
43119  ImageKit & SetCompressionQuality(float in_quality);
43120 
43123  ImageKit & UnsetSize();
43124 
43127  ImageKit & UnsetData();
43128 
43131  ImageKit & UnsetFormat();
43132 
43135  ImageKit & UnsetDownSampling();
43136 
43139  ImageKit & UnsetCompressionQuality();
43140 
43143  ImageKit & UnsetEverything();
43144 
43149  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
43150 
43154  bool ShowData(ByteArray & out_image_data) const;
43155 
43159  bool ShowFormat(Image::Format & out_format) const;
43160 
43164  bool ShowDownSampling(bool & out_state) const;
43165 
43169  bool ShowCompressionQuality(float & out_quality) const;
43170 };
43171 
43172 
43178 {
43179 public:
43183 
43188 
43193 
43198 
43200 
43201  virtual HPS::Type Type() const { return ObjectType(); }
43202 
43203  static const HPS::Type staticType = HPS::Type::OffScreenWindowOptionsControl;
43204  HPS::Type ObjectType() const { return staticType; };
43205 
43209  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
43210 
43215  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
43216 
43221  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
43222 
43225  OffScreenWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
43226 
43228  OffScreenWindowOptionsControl & UnsetFallbackFonts();
43229 
43232  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
43233 
43237  bool ShowDriver(Window::Driver & out_driver) const;
43238 
43243  OffScreenWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
43244 
43248  OffScreenWindowOptionsControl & SetScreenAntiAliasing(bool in_state);
43249 
43254  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
43255 
43260  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
43261 
43266  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
43267 
43272  bool ShowImage(ByteArray & out_bytes) const;
43273 
43277  bool ShowHardwareResident(bool & out_state) const;
43278 
43283  bool ShowOpacity(bool & out_state, float & out_opacity) const;
43284 
43289  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
43290 
43294  bool ShowFramebufferRetention(bool & out_retain) const;
43295 
43296 
43297 private:
43300 };
43301 
43302 
43305 class HPS_API OffScreenWindowKey : public WindowKey
43306 {
43307 public:
43310 
43315  OffScreenWindowKey(Key const & in_key);
43316 
43319  OffScreenWindowKey(OffScreenWindowKey const & in_that);
43320 
43325 
43329  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
43330 
43331  ~OffScreenWindowKey();
43332 
43333  static const HPS::Type staticType = HPS::Type::OffScreenWindowKey;
43334  HPS::Type ObjectType() const { return staticType; };
43335 
43338  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
43339 
43342  OffScreenWindowOptionsControl GetWindowOptionsControl();
43343 
43347  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
43348 };
43349 
43350 
43351 
43352 
43354 class HPS_API ImageDefinition : public Definition
43355 {
43356 public:
43358  ImageDefinition();
43359 
43364  ImageDefinition(Definition const & in_that);
43365 
43368  ImageDefinition(ImageDefinition const & in_that);
43369 
43373  ImageDefinition & operator=(ImageDefinition const & in_that);
43374 
43378  ImageDefinition(ImageDefinition && in_that);
43379 
43383  ImageDefinition & operator=(ImageDefinition && in_that);
43384 
43385  ~ImageDefinition();
43386 
43387  static const HPS::Type staticType = HPS::Type::ImageDefinition;
43388  HPS::Type ObjectType() const { return staticType; };
43389 
43392  void Set(ImageKit const & in_kit);
43393 
43396  void Show(ImageKit & out_kit) const;
43397 };
43398 
43400 class HPS_API CubeMapDefinition : public Definition
43401 {
43402 public:
43405 
43410  CubeMapDefinition(Definition const & in_that);
43411 
43414  CubeMapDefinition(CubeMapDefinition const & in_that);
43415 
43419  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
43420 
43425 
43429  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
43430 
43431  ~CubeMapDefinition();
43432 
43433  static const HPS::Type staticType = HPS::Type::CubeMapDefinition;
43434  HPS::Type ObjectType() const { return staticType; };
43435 
43443  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
43444  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
43445  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
43446 
43454  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
43455  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
43456  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
43457 
43461  void ShowSource(ImageDefinitionArray & out_image_sources) const;
43462 
43465  void SetOptions(TextureOptionsKit const & in_options);
43466 
43469  void ShowOptions(TextureOptionsKit & out_options) const;
43470 };
43471 
43472 
43474 class HPS_API NamedStyleDefinition : public Definition
43475 {
43476 public:
43479 
43484  NamedStyleDefinition(Definition const & in_that);
43485 
43488  NamedStyleDefinition(NamedStyleDefinition const & in_that);
43489 
43493  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
43494 
43499 
43503  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
43504 
43506 
43507  static const HPS::Type staticType = HPS::Type::NamedStyleDefinition;
43508  HPS::Type ObjectType() const { return staticType; };
43509 
43513  SegmentKey GetSource() const;
43514 };
43515 
43516 
43519 {
43520 public:
43523 
43528  MaterialPaletteDefinition(Definition const & in_that);
43529 
43533 
43537  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
43538 
43543 
43547  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
43548 
43550 
43551  static const HPS::Type staticType = HPS::Type::MaterialPaletteDefinition;
43552  HPS::Type ObjectType() const { return staticType; };
43553 
43556  void Set(MaterialKitArray const & in_source);
43557 
43561  void Set(size_t in_count, MaterialKit const in_source []);
43562 
43565  void Show(MaterialKitArray & out_source) const;
43566 };
43567 
43568 
43569 
43571 class HPS_API LinePatternDefinition : public Definition
43572 {
43573 public:
43576 
43581  LinePatternDefinition(Definition const & in_that);
43582 
43586 
43590  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
43591 
43596 
43600  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
43601 
43603 
43604  static const HPS::Type staticType = HPS::Type::LinePatternDefinition;
43605  HPS::Type ObjectType() const { return staticType; };
43606 
43609  void Set(LinePatternKit const & in_kit);
43610 
43613  void Show(LinePatternKit & out_kit) const;
43614 };
43615 
43616 
43617 
43619 class HPS_API Shader
43620 {
43621 public:
43624  enum class Parameterization : uint32_t
43625  {
43627  Cylinder,
43629  PhysicalReflection,
43631  Object,
43637  NaturalUV,
43639  ReflectionVector,
43641  SurfaceNormal,
43643  Sphere,
43645  UV,
43647  World
43648  };
43649 
43651 class HPS_API ImportOptionsKit : public Kit
43652  {
43653  public:
43655  ImportOptionsKit();
43656 
43659  ImportOptionsKit(ImportOptionsKit const & in_kit);
43660 
43664  ImportOptionsKit(ImportOptionsKit && in_that);
43665 
43669  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
43670 
43671  virtual ~ImportOptionsKit();
43672 
43673  static const HPS::Type staticType = HPS::Type::ShaderImportOptionsKit;
43674  HPS::Type ObjectType() const { return staticType; };
43675 
43678  void Set(ImportOptionsKit const & in_kit);
43679 
43682  void Show(ImportOptionsKit & out_kit) const;
43683 
43687  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
43688 
43691  bool Empty() const;
43692 
43696  bool Equals(ImportOptionsKit const & in_kit) const;
43697 
43701  bool operator==(ImportOptionsKit const & in_kit) const;
43702 
43706  bool operator!=(ImportOptionsKit const & in_kit) const;
43707 
43714  ImportOptionsKit & SetMultitexture(bool in_state);
43715 
43719  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
43720 
43724  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
43725 
43729  ImportOptionsKit & UnsetMultitexture();
43730 
43733  ImportOptionsKit & UnsetParameterizationSource();
43734 
43737  ImportOptionsKit & UnsetTransformMatrix();
43738 
43741  ImportOptionsKit & UnsetEverything();
43742 
43748  bool ShowMultitexture(bool & out_state) const;
43749 
43753  bool ShowParameterizationSource(Parameterization & out_source) const;
43754 
43758  bool ShowTransformMatrix(MatrixKit & out_transform) const;
43759  };
43760 
43762  class HPS_API File
43763  {
43764  public:
43770  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
43771 
43772  private:
43774  File();
43775  };
43776 
43777 private:
43779  Shader();
43780 };
43781 
43782 
43784 class HPS_API ShaderKit : public Kit
43785 {
43786 public:
43788  ShaderKit();
43789 
43792  ShaderKit(ShaderKit const & in_kit);
43793 
43797  ShaderKit(ShaderKit && in_that);
43798 
43802  ShaderKit & operator=(ShaderKit && in_that);
43803 
43804  virtual ~ShaderKit();
43805 
43806  static const HPS::Type staticType = HPS::Type::ShaderKit;
43807  HPS::Type ObjectType() const { return staticType; };
43808 
43811  void Set(ShaderKit const & in_kit);
43812 
43815  void Show(ShaderKit & out_kit) const;
43816 
43820  ShaderKit & operator=(ShaderKit const & in_kit);
43821 
43824  bool Empty() const;
43825 
43829  bool Equals(ShaderKit const & in_kit) const;
43830 
43834  bool operator==(ShaderKit const & in_kit) const;
43835 
43839  bool operator!=(ShaderKit const & in_kit) const;
43840 
43844  ShaderKit & SetSource(char const * in_source);
43845 
43852  ShaderKit & SetMultitexture(bool in_state);
43853 
43857  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
43858 
43862  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
43863 
43866  ShaderKit & UnsetSource();
43867 
43871  ShaderKit & UnsetMultitexture();
43872 
43875  ShaderKit & UnsetParameterizationSource();
43876 
43879  ShaderKit & UnsetTransformMatrix();
43880 
43883  ShaderKit & UnsetEverything();
43884 
43888  bool ShowSource(UTF8 & out_source) const;
43889 
43895  bool ShowMultitexture(bool & out_state) const;
43896 
43900  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
43901 
43905  bool ShowTransformMatrix(MatrixKit & out_transform) const;
43906 };
43907 
43908 
43910 class HPS_API ShaderDefinition : public Definition
43911 {
43912 public:
43914  ShaderDefinition();
43915 
43920  ShaderDefinition(Definition const & in_that);
43921 
43924  ShaderDefinition(ShaderDefinition const & in_that);
43925 
43929  ShaderDefinition & operator=(ShaderDefinition const & in_that);
43930 
43934  ShaderDefinition(ShaderDefinition && in_that);
43935 
43939  ShaderDefinition & operator=(ShaderDefinition && in_that);
43940 
43941  ~ShaderDefinition();
43942 
43943  static const HPS::Type staticType = HPS::Type::ShaderDefinition;
43944  HPS::Type ObjectType() const { return staticType; };
43945 
43948  void Set(ShaderKit const & in_kit);
43949 
43952  void Show(ShaderKit & out_kit) const;
43953 };
43954 
43956 class HPS_API ShapeKit : public Kit
43957 {
43958 public:
43960  ShapeKit();
43961 
43964  ShapeKit(ShapeKit const & in_kit);
43965 
43969  ShapeKit(ShapeKit && in_that);
43970 
43974  ShapeKit & operator=(ShapeKit && in_that);
43975 
43976  virtual ~ShapeKit();
43977 
43978  static const HPS::Type staticType = HPS::Type::ShapeKit;
43979  HPS::Type ObjectType() const { return staticType; };
43980 
43983  void Set(ShapeKit const & in_kit);
43984 
43987  void Show(ShapeKit & out_kit) const;
43988 
43992  ShapeKit & operator=(ShapeKit const & in_kit);
43993 
43996  bool Empty() const;
43997 
44001  bool Equals(ShapeKit const & in_kit) const;
44002 
44006  bool operator==(ShapeKit const & in_kit) const;
44007 
44011  bool operator!=(ShapeKit const & in_kit) const;
44012 
44016  static HPS::ShapeKit GetDefault(Shape::Default in_default_shape);
44017 
44021  ShapeKit & SetElements(ShapeElementArray const & in_def);
44022 
44027  ShapeKit & SetElements(size_t in_count, ShapeElement const in_def []);
44028 
44032  ShapeKit & SetElement(ShapeElement const & in_element);
44033 
44036  ShapeKit & UnsetElements();
44037 
44040  ShapeKit & UnsetEverything();
44041 
44045  bool ShowElements(ShapeElementArray & out_def) const;
44046 
44047 };
44048 
44050 class HPS_API ShapeDefinition : public Definition
44051 {
44052 public:
44054  ShapeDefinition();
44055 
44060  ShapeDefinition(Definition const & in_that);
44061 
44064  ShapeDefinition(ShapeDefinition const & in_that);
44065 
44069  ShapeDefinition & operator=(ShapeDefinition const & in_that);
44070 
44074  ShapeDefinition(ShapeDefinition && in_that);
44075 
44079  ShapeDefinition & operator=(ShapeDefinition && in_that);
44080 
44081  ~ShapeDefinition();
44082 
44083  static const HPS::Type staticType = HPS::Type::ShapeDefinition;
44084  HPS::Type ObjectType() const { return staticType; };
44085 
44088  void Set(ShapeKit const & in_kit);
44089 
44092  void Show(ShapeKit & out_kit) const;
44093 };
44094 
44095 
44099 class HPS_API CutGeometryGatheringOptionsKit : public Kit
44100 {
44101 public:
44104 
44108 
44113 
44118 
44119  virtual ~CutGeometryGatheringOptionsKit();
44120 
44121  static const HPS::Type staticType = HPS::Type::CutGeometryGatheringOptionsKit;
44122  HPS::Type ObjectType() const {return staticType;};
44123 
44127  static CutGeometryGatheringOptionsKit GetDefault();
44128 
44131  void Set(CutGeometryGatheringOptionsKit const & in_kit);
44132 
44135  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
44136 
44141 
44144  bool Empty() const;
44145 
44149  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
44150 
44154  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
44155 
44159  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
44160 
44161 
44165  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
44166 
44170  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
44171 
44176 
44180  CutGeometryGatheringOptionsKit & SetColor(bool in_color);
44181 
44182 
44185  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
44186 
44189  CutGeometryGatheringOptionsKit & UnsetOffset();
44190 
44193  CutGeometryGatheringOptionsKit & UnsetLevel();
44194 
44197  CutGeometryGatheringOptionsKit & UnsetColor();
44198 
44201  CutGeometryGatheringOptionsKit & UnsetEverything();
44202 
44203 
44207  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
44208 
44212  bool ShowOffset(size_t & out_offset) const;
44213 
44217  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
44218 
44222  bool ShowColor(bool & out_color) const;
44223 };
44224 
44226 class HPS_API SearchOptionsKit : public Kit
44227 {
44228 public:
44230  SearchOptionsKit();
44231 
44234  SearchOptionsKit(SearchOptionsKit const & in_kit);
44235 
44239  SearchOptionsKit(SearchOptionsKit && in_that);
44240 
44244  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
44245 
44246  virtual ~SearchOptionsKit();
44247 
44248  static const HPS::Type staticType = HPS::Type::SearchOptionsKit;
44249  HPS::Type ObjectType() const {return staticType;};
44250 
44254  static SearchOptionsKit GetDefault();
44255 
44258  void Set(SearchOptionsKit const & in_kit);
44259 
44262  void Show(SearchOptionsKit & out_kit) const;
44263 
44267  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
44268 
44271  bool Empty() const;
44272 
44276  bool Equals(SearchOptionsKit const & in_kit) const;
44277 
44281  bool operator==(SearchOptionsKit const & in_kit) const;
44282 
44286  bool operator!=(SearchOptionsKit const & in_kit) const;
44287 
44291  SearchOptionsKit & SetCriteria(Search::Type in_request);
44292 
44296  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
44297 
44301  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
44302 
44307  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
44308 
44312  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
44313 
44316  SearchOptionsKit & UnsetBehavior();
44317 
44320  SearchOptionsKit & UnsetCriteria();
44321 
44324  SearchOptionsKit & UnsetSearchSpace();
44325 
44328  SearchOptionsKit & UnsetEverything();
44329 
44333  bool ShowBehavior(Search::Behavior & out_behavior) const;
44334 
44338  bool ShowCriteria(SearchTypeArray & out_types) const;
44339 
44343  bool ShowSearchSpace(Search::Space & out_search_space) const;
44344 };
44345 
44349 class HPS_API TreeContext : public Object
44350 {
44351 public:
44354  TreeContext(bool in_create = true);
44355 
44358  TreeContext(TreeContext const & in_that);
44359 
44363  TreeContext(TreeContext && in_that);
44364 
44368  TreeContext & operator=(TreeContext && in_that);
44369 
44371  virtual ~TreeContext();
44372 
44373  static const HPS::Type staticType = HPS::Type::TreeContext;
44374  HPS::Type ObjectType() const {return staticType;};
44375 
44379  TreeContext & operator=(TreeContext const & in_that);
44380 
44384  bool Equals(TreeContext const & in_that) const;
44385 
44389  bool operator==(TreeContext const & in_that) const;
44390 
44394  bool operator!=(TreeContext const & in_that) const;
44395 
44396 };
44397 
44399 class HPS_API SelectionOptionsKit : public Kit
44400 {
44401 public:
44404 
44407  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
44408 
44413 
44417  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
44418 
44419  virtual ~SelectionOptionsKit();
44420 
44421  static const HPS::Type staticType = HPS::Type::SelectionOptionsKit;
44422  HPS::Type ObjectType() const {return staticType;};
44423 
44427  static SelectionOptionsKit GetDefault();
44428 
44431  void Set(SelectionOptionsKit const & in_kit);
44432 
44435  void Show(SelectionOptionsKit & out_kit) const;
44436 
44440  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
44441 
44444  bool Empty() const;
44445 
44449  bool Equals(SelectionOptionsKit const & in_kit) const;
44450 
44454  bool operator==(SelectionOptionsKit const & in_kit) const;
44455 
44459  bool operator!=(SelectionOptionsKit const & in_kit) const;
44460 
44490  SelectionOptionsKit & SetProximity(float in_proximity);
44491 
44497  SelectionOptionsKit & SetLevel(Selection::Level in_level);
44498 
44504  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
44505 
44516  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
44517 
44525  SelectionOptionsKit & SetSorting(bool in_sorting);
44526 
44543  SelectionOptionsKit & SetSorting(Selection::Sorting in_sorting);
44544 
44550  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
44551 
44557  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
44558 
44565  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment, bool in_scope_only = false);
44566 
44573  SelectionOptionsKit & SetScope(KeyPath const & in_start_path, bool in_scope_only = false);
44574 
44579  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
44580 
44587  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
44588 
44595  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
44596 
44603  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
44604 
44611  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
44612 
44619  SelectionOptionsKit & SetVolumeCullingRespected(bool in_state);
44620 
44627  SelectionOptionsKit & SetDistanceCullingRespected(bool in_state);
44628 
44632  SelectionOptionsKit & SetSelectability(SelectabilityKit const & in_selectability);
44633 
44638  SelectionOptionsKit & SetCondition(char const * in_condition);
44639 
44644  SelectionOptionsKit & SetConditions(UTF8Array const & in_conditions);
44645 
44650  SelectionOptionsKit & SetConditions(size_t in_count, UTF8 const in_conditions[]);
44651 
44652 
44655  SelectionOptionsKit & UnsetSelectability();
44656 
44659  SelectionOptionsKit & UnsetProximity();
44660 
44663  SelectionOptionsKit & UnsetLevel();
44664 
44667  SelectionOptionsKit & UnsetInternalLimit();
44668 
44671  SelectionOptionsKit & UnsetRelatedLimit();
44672 
44675  SelectionOptionsKit & UnsetSorting();
44676 
44679  SelectionOptionsKit & UnsetAlgorithm();
44680 
44683  SelectionOptionsKit & UnsetGranularity();
44684 
44687  SelectionOptionsKit & UnsetScope();
44688 
44691  SelectionOptionsKit & UnsetTreeContext();
44692 
44695  SelectionOptionsKit & UnsetExtentCullingRespected();
44696 
44699  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
44700 
44703  SelectionOptionsKit & UnsetFrustumCullingRespected();
44704 
44707  SelectionOptionsKit & UnsetVectorCullingRespected();
44708 
44711  SelectionOptionsKit & UnsetVolumeCullingRespected();
44712 
44715  SelectionOptionsKit & UnsetDistanceCullingRespected();
44716 
44718  SelectionOptionsKit & UnsetConditions();
44719 
44722  SelectionOptionsKit & UnsetEverything();
44723 
44724 
44728  bool ShowProximity(float & out_proximity) const;
44729 
44733  bool ShowLevel(Selection::Level & out_level) const;
44734 
44738  bool ShowInternalLimit(size_t & out_limit) const;
44739 
44743  bool ShowRelatedLimit(size_t & out_limit) const;
44744 
44748  bool ShowSorting(Selection::Sorting & out_sorting) const;
44749 
44753  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
44754 
44758  bool ShowGranularity(Selection::Granularity & out_granularity) const;
44759 
44765  bool ShowScope(KeyPath & out_start_path, bool & out_scope_only) const;
44766 
44770  bool ShowTreeContext(TreeContext & out_tree_context) const;
44771 
44775  bool ShowExtentCullingRespected(bool & out_state) const;
44776 
44780  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
44781 
44785  bool ShowFrustumCullingRespected(bool & out_state) const;
44786 
44790  bool ShowVectorCullingRespected(bool & out_state) const;
44791 
44795  bool ShowVolumeCullingRespected(bool & out_state) const;
44796 
44800  bool ShowDistanceCullingRespected(bool & out_state) const;
44801 
44805  bool ShowSelectability(HPS::SelectabilityKit & out_selectability) const;
44806 
44809  bool ShowConditions(UTF8Array & out_conditions) const;
44810 };
44811 
44812 
44813 
44817 class HPS_API SelectionOptionsControl : public Control
44818 {
44819 public:
44822  explicit SelectionOptionsControl(WindowKey const & in_window);
44823 
44827 
44832 
44836  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
44837 
44839 
44840  virtual HPS::Type Type() const { return ObjectType(); }
44841 
44842  static const HPS::Type staticType = HPS::Type::SelectionOptionsControl;
44843  HPS::Type ObjectType() const {return staticType;};
44844 
44848  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
44849 
44879  SelectionOptionsControl & SetProximity(float in_proximity);
44880 
44886  SelectionOptionsControl & SetLevel(Selection::Level in_level);
44887 
44894  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
44895 
44905  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
44906 
44914  SelectionOptionsControl & SetSorting(bool in_sorting);
44915 
44932  SelectionOptionsControl & SetSorting(Selection::Sorting in_sorting);
44933 
44939  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
44940 
44946  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
44947 
44954  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
44955 
44962  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
44963 
44970  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
44971 
44978  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
44979 
44986  SelectionOptionsControl & SetVolumeCullingRespected(bool in_state);
44987 
44994  SelectionOptionsControl & SetDistanceCullingRespected(bool in_state);
44995 
44996 
45000  SelectionOptionsControl & UnsetProximity();
45001 
45005  SelectionOptionsControl & UnsetLevel();
45006 
45010  SelectionOptionsControl & UnsetInternalLimit();
45011 
45015  SelectionOptionsControl & UnsetRelatedLimit();
45016 
45020  SelectionOptionsControl & UnsetSorting();
45021 
45025  SelectionOptionsControl & UnsetAlgorithm();
45026 
45030  SelectionOptionsControl & UnsetGranularity();
45031 
45035  SelectionOptionsControl & UnsetExtentCullingRespected();
45036 
45040  SelectionOptionsControl & UnsetDeferralExtentCullingRespected();
45041 
45045  SelectionOptionsControl & UnsetFrustumCullingRespected();
45046 
45050  SelectionOptionsControl & UnsetVectorCullingRespected();
45051 
45055  SelectionOptionsControl & UnsetVolumeCullingRespected();
45056 
45060  SelectionOptionsControl & UnsetDistanceCullingRespected();
45061 
45065  SelectionOptionsControl & UnsetEverything();
45066 
45070  bool ShowProximity(float & out_proximity) const;
45071 
45075  bool ShowLevel(Selection::Level & out_level) const;
45076 
45080  bool ShowInternalLimit(size_t & out_limit) const;
45081 
45085  bool ShowRelatedLimit(size_t & out_limit) const;
45086 
45090  bool ShowSorting(Selection::Sorting & out_sorting) const;
45091 
45095  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
45096 
45100  bool ShowGranularity(Selection::Granularity & out_granularity) const;
45101 
45105  bool ShowExtentCullingRespected(bool & out_state) const;
45106 
45110  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
45111 
45115  bool ShowFrustumCullingRespected(bool & out_state) const;
45116 
45120  bool ShowVectorCullingRespected(bool & out_state) const;
45121 
45125  bool ShowVolumeCullingRespected(bool & out_state) const;
45126 
45130  bool ShowDistanceCullingRespected(bool & out_state) const;
45131 
45132 private:
45135 };
45136 
45137 
45138 
45140 class HPS_API SelectionItem : public Object
45141 {
45142 public:
45144  SelectionItem();
45145 
45148  SelectionItem(SelectionItem const & in_that);
45149 
45153  SelectionItem(SelectionItem && in_that);
45154 
45158  SelectionItem & operator=(SelectionItem && in_that);
45159 
45160  virtual ~SelectionItem();
45161 
45162  static const HPS::Type staticType = HPS::Type::SelectionItem;
45163  HPS::Type ObjectType() const {return staticType;};
45164 
45167  void Set(SelectionItem const & in_that);
45168 
45172  SelectionItem & operator=(SelectionItem const & in_that);
45173 
45177  bool Equals(SelectionItem const & in_that) const;
45178 
45182  bool operator==(SelectionItem const & in_that) const;
45183 
45187  bool operator!=(SelectionItem const & in_that) const;
45188 
45192  bool ShowSelectionLevel(Selection::Level & out_level) const;
45193 
45197  bool ShowSelectedItem(Key & out_selection) const;
45198 
45202  bool ShowPath(KeyPath & out_path) const;
45203 
45207  bool ShowFaces(SizeTArray & out_faces) const;
45208 
45212  bool ShowVertices(SizeTArray & out_vertices) const;
45213 
45218  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
45219 
45223  bool ShowCharacters(SizeTArray & out_characters) const;
45224 
45228  bool ShowSelectionPosition(WindowPoint & out_location) const;
45229 
45233  bool ShowSelectionPosition(WorldPoint & out_location) const;
45234 
45238  bool ShowNormalizedSelectionPosition(WindowPoint & out_location) const;
45239 
45240 };
45241 
45243 class HPS_API SelectionResultsIterator : public Object
45244 {
45245 public:
45248 
45253 
45258 
45262  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
45263 
45265 
45266  static const HPS::Type staticType = HPS::Type::SelectionResultsIterator;
45267  HPS::Type ObjectType() const {return staticType;}
45268 
45272  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
45273 
45276  void Set(SelectionResultsIterator const & in_that);
45277 
45279  void Next();
45280 
45283  SelectionResultsIterator & operator++();
45284 
45287  SelectionResultsIterator operator++(int in_val);
45288 
45291  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
45292 
45295  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
45296 
45297 
45300  bool IsValid() const;
45301 
45303  void Reset();
45304 
45307  SelectionItem GetItem() const;
45308 
45311  SelectionItem operator*() const;
45312 
45313 
45314 };
45315 
45319 class HPS_API SelectionResults : public Object
45320 {
45321 public:
45323  SelectionResults();
45324 
45327  SelectionResults(SelectionResults const & in_that);
45328 
45332  SelectionResults(SelectionResults && in_that);
45333 
45337  SelectionResults & operator=(SelectionResults && in_that);
45338 
45339  ~SelectionResults();
45340 
45341  static const HPS::Type staticType = HPS::Type::SelectionResults;
45342  HPS::Type ObjectType() const {return staticType;}
45343 
45346  void Assign(SelectionResults const & in_that);
45347 
45351  SelectionResults & operator=(SelectionResults const & in_that);
45352 
45356  bool Equals(SelectionResults const & in_that) const;
45357 
45361  bool operator==(SelectionResults const & in_that) const;
45362 
45366  bool operator!=(SelectionResults const & in_that) const;
45367 
45369  virtual void Reset();
45370 
45373  Selection::Level GetSelectionLevel() const;
45374 
45377  size_t GetCount() const;
45378 
45381  SelectionResultsIterator GetIterator() const;
45382 
45388  bool Union(SelectionResults const & in_that);
45389 
45394  bool Intersect(SelectionResults const & in_that);
45395 
45401  bool SymmetricDifference(SelectionResults const & in_that);
45402 
45407  bool Difference(SelectionResults const & in_that);
45408 
45411  void Copy(SelectionResults const & in_that);
45412 };
45413 
45416 class HPS_API SelectionControl : public Control
45417 {
45418 public:
45421  explicit SelectionControl(WindowKey const & in_window);
45422 
45425  SelectionControl(SelectionControl const & in_that);
45426 
45430  SelectionControl(SelectionControl && in_that);
45431 
45435  SelectionControl & operator=(SelectionControl && in_that);
45436 
45437  ~SelectionControl();
45438 
45439  static const HPS::Type staticType = HPS::Type::SelectionControl;
45440  HPS::Type ObjectType() const {return staticType;};
45441 
45445  SelectionControl & operator=(SelectionControl const & in_that);
45446 
45452  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45453 
45458  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
45459 
45465  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45466 
45471  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
45472 
45479  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45480 
45486  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
45487 
45495  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45496 
45503  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
45504 
45511  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45512 
45518  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
45519 
45527  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
45528 
45535  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
45536 
45537 
45538  //Object space selections
45539 
45545  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45546 
45551  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
45552 
45558  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45559 
45564  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
45565 
45566 
45573  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45574 
45580  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
45581 
45582 
45589  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
45590 
45596  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
45597 
45598 private:
45600  SelectionControl();
45601 };
45602 
45603 
45604 
45606 class HPS_API HighlightOptionsKit : public Kit
45607 {
45608 public:
45611 
45614  HighlightOptionsKit(char const * in_style_name);
45615 
45619  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
45620 
45623  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
45624 
45629 
45633  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
45634 
45635  virtual ~HighlightOptionsKit();
45636 
45637  static const HPS::Type staticType = HPS::Type::HighlightOptionsKit;
45638  HPS::Type ObjectType() const {return staticType;};
45639 
45643  static HighlightOptionsKit GetDefault();
45644 
45647  void Set(HighlightOptionsKit const & in_kit);
45648 
45651  void Show(HighlightOptionsKit & out_kit) const;
45652 
45656  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
45657 
45660  bool Empty() const;
45661 
45665  bool Equals(HighlightOptionsKit const & in_kit) const;
45666 
45670  bool operator==(HighlightOptionsKit const & in_kit) const;
45671 
45675  bool operator!=(HighlightOptionsKit const & in_kit) const;
45676 
45682  HighlightOptionsKit & SetPassive(bool in_pasive);
45683 
45688  HighlightOptionsKit & SetStyleName(char const * in_style_name);
45689 
45693  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
45694 
45703  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
45704 
45710  HighlightOptionsKit & SetNotification(bool in_state);
45711 
45715  HighlightOptionsKit & SetSubentityHighlighting(bool in_enable);
45716 
45719  HighlightOptionsKit & UnsetPassive();
45720 
45723  HighlightOptionsKit & UnsetStyleName();
45724 
45727  HighlightOptionsKit & UnsetSecondaryStyleName();
45728 
45731  HighlightOptionsKit & UnsetOverlay();
45732 
45735  HighlightOptionsKit & UnsetNotification();
45736 
45739  HighlightOptionsKit & UnsetSubentityHighlighting();
45740 
45743  HighlightOptionsKit & UnsetEverything();
45744 
45748  bool ShowPassive(bool & out_pasive) const;
45749 
45753  bool ShowStyleName(UTF8 & out_style_name) const;
45754 
45758  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
45759 
45763  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
45764 
45768  bool ShowNotification(bool & out_state) const;
45769 
45773  bool ShowSubentityHighlighting(bool & out_enable) const;
45774 };
45775 
45778 class HPS_API HighlightSearchOptionsKit : public Kit
45779 {
45780 public:
45783 
45787 
45792 
45796  HighlightSearchOptionsKit & operator=(HighlightSearchOptionsKit && in_that);
45797 
45798  virtual ~HighlightSearchOptionsKit();
45799 
45800  static const HPS::Type staticType = HPS::Type::HighlightSearchOptionsKit;
45801  HPS::Type ObjectType() const { return staticType; };
45802 
45806  static HighlightSearchOptionsKit GetDefault();
45807 
45810  void Set(HighlightSearchOptionsKit const & in_kit);
45811 
45814  void Show(HighlightSearchOptionsKit & out_kit) const;
45815 
45819  HighlightSearchOptionsKit & operator=(HighlightSearchOptionsKit const & in_kit);
45820 
45823  bool Empty() const;
45824 
45828  bool Equals(HighlightSearchOptionsKit const & in_kit) const;
45829 
45833  bool operator==(HighlightSearchOptionsKit const & in_kit) const;
45834 
45838  bool operator!=(HighlightSearchOptionsKit const & in_kit) const;
45839 
45840 
45844  HighlightSearchOptionsKit & SetStyleName(char const * in_style_name);
45845 
45849  HighlightSearchOptionsKit & SetStyleNames(UTF8Array const & in_style_names);
45850 
45854  HighlightSearchOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
45855 
45859  HighlightSearchOptionsKit & SetOverlays(DrawingOverlayArray const & in_overlays);
45860 
45861 
45864  HighlightSearchOptionsKit & UnsetStyleNames();
45865 
45868  HighlightSearchOptionsKit & UnsetOverlays();
45869 
45872  HighlightSearchOptionsKit & UnsetEverything();
45873 
45874 
45878  bool ShowStyleNames(UTF8Array & out_style_names) const;
45879 
45883  bool ShowOverlays(DrawingOverlayArray & out_overlays) const;
45884 };
45885 
45887 class HPS_API HighlightState : public Object
45888 {
45889 public:
45891  HighlightState();
45892 
45895  HighlightState(HighlightState const & in_that);
45896 
45900  HighlightState(HighlightState && in_that);
45901 
45905  HighlightState & operator=(HighlightState && in_that);
45906 
45907  ~HighlightState();
45908 
45909  static const HPS::Type staticType = HPS::Type::HighlightState;
45910  HPS::Type ObjectType() const { return staticType; };
45911 
45914  void Assign(HighlightState const & in_that);
45915 
45919  HighlightState & operator=(HighlightState const & in_that);
45920 
45924  bool Equals(HighlightState const & in_that) const;
45925 
45929  bool operator== (HighlightState const & in_that) const;
45930 
45934  bool operator!= (HighlightState const & in_that) const;
45935 
45938  void Set(bool in_directly_highlighted, bool in_subentity_highlighted, bool in_inherits_highlight, bool in_on_highlight_path);
45939 
45942  bool GetDirectlyHighlighted() const;
45943 
45947  bool GetSubentityHighlighted() const;
45948 
45951  bool GetInheritsHighlight() const;
45952 
45955  bool GetOnHighlightPath() const;
45956 };
45957 
45960 {
45961 public:
45962 
45965 
45969  HighlightSearchResultsIterator(HighlightSearchResultsIterator const & in_search_results_iterator);
45970 
45975 
45980 
45982 
45983  static const HPS::Type staticType = HPS::Type::HighlightSearchResultsIterator;
45984  HPS::Type ObjectType() const { return staticType; }
45985 
45990  HighlightSearchResultsIterator & operator=(HighlightSearchResultsIterator const & in_search_results_iterator);
45991 
45996  void Set(HighlightSearchResultsIterator const & in_search_results_iterator);
45997 
45999  void Next();
46000 
46003  HighlightSearchResultsIterator & operator++();
46004 
46007  HighlightSearchResultsIterator operator++(int in_val);
46008 
46011  bool operator==(HighlightSearchResultsIterator const & in_search_results_iterator);
46012 
46015  bool operator!=(HighlightSearchResultsIterator const & in_search_results_iterator);
46016 
46020  bool IsValid() const;
46021 
46023  void Reset();
46024 
46028  KeyPath GetItem() const;
46029 
46032  KeyPath operator*() const;
46033 
46037  UTF8 GetStyleName() const;
46038 
46042  Drawing::Overlay GetOverlay() const;
46043 
46047  bool GetPassive() const;
46048 };
46049 
46051 class HPS_API HighlightSearchResults : public Object
46052 {
46053 public:
46056 
46059  HighlightSearchResults(HighlightSearchResults const & in_search_results);
46060 
46065 
46069  HighlightSearchResults & operator=(HighlightSearchResults && in_that);
46070 
46072  virtual void Reset();
46073 
46076 
46077  static const HPS::Type staticType = HPS::Type::HighlightSearchResults;
46078  HPS::Type ObjectType() const { return staticType; }
46079 
46083  void Assign(HighlightSearchResults const & in_search_results);
46084 
46088  HighlightSearchResults & operator=(HighlightSearchResults const & in_search_results);
46089 
46092  size_t GetCount() const;
46093 
46096  HighlightSearchResultsIterator GetIterator() const;
46097 };
46098 
46099 
46100 
46103 {
46104 public:
46105 
46108 
46112  OptimizeMappingResultsIterator(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
46113 
46118 
46123 
46125 
46126  static const HPS::Type staticType = HPS::Type::OptimizeMappingResultsIterator;
46127  HPS::Type ObjectType() const { return staticType; }
46128 
46133  OptimizeMappingResultsIterator & operator=(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
46134 
46139  void Set(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
46140 
46142  void Next();
46143 
46146  OptimizeMappingResultsIterator & operator++();
46147 
46150  OptimizeMappingResultsIterator operator++(int in_val);
46151 
46154  bool operator==(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
46155 
46158  bool operator!=(OptimizeMappingResultsIterator const & in_mapping_results_iterator);
46159 
46163  bool IsValid() const;
46164 
46166  void Reset();
46167 
46171  Key GetItem() const;
46172 
46175  Key operator*() const;
46176 
46183  bool GetMergedShellInfo(ShellKey & out_shell_key, size_t & out_vertex_offset, size_t & out_face_offset, size_t & out_edge_offset) const;
46184 
46185 };
46186 
46188 class HPS_API OptimizeMappingResults : public Object
46189 {
46190 public:
46193 
46196  OptimizeMappingResults(OptimizeMappingResults const & in_mappping);
46197 
46202 
46206  OptimizeMappingResults & operator=(OptimizeMappingResults && in_that);
46207 
46209  virtual void Reset();
46210 
46213 
46214  static const HPS::Type staticType = HPS::Type::OptimizeMappingResults;
46215  HPS::Type ObjectType() const { return staticType; }
46216 
46220  void Assign(OptimizeMappingResults const & in_mappping);
46221 
46225  OptimizeMappingResults & operator=(OptimizeMappingResults const & in_mappping);
46226 
46229  size_t GetCount() const;
46230 
46234  bool FlushMerged();
46235 
46238  OptimizeMappingResultsIterator GetIterator() const;
46239 };
46240 
46241 
46244 class HPS_API HighlightControl : public Control
46245 {
46246 public:
46249  explicit HighlightControl(WindowKey const & in_window);
46250 
46253  HighlightControl(HighlightControl const & in_that);
46254 
46258  HighlightControl(HighlightControl && in_that);
46259 
46263  HighlightControl & operator=(HighlightControl && in_that);
46264 
46265  ~HighlightControl();
46266 
46267  virtual HPS::Type Type() const { return ObjectType(); }
46268 
46269  static const HPS::Type staticType = HPS::Type::HighlightControl;
46270  HPS::Type ObjectType() const {return staticType;};
46271 
46275  HighlightControl & operator=(HighlightControl const & in_that);
46276 
46282  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
46283 
46289  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
46290 
46296  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
46297 
46303  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
46304 
46310  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options, bool in_remove_existing = true);
46311 
46321  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces, bool in_remove_existing = true);
46322 
46332  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces, bool in_remove_existing = true);
46333 
46346  HighlightControl & Highlight(
46347  KeyPath const & in_item,
46348  HighlightOptionsKit const & in_options,
46349  size_t in_vertices_count,
46350  size_t const in_vertices[],
46351  size_t in_edges_count,
46352  size_t const in_edges1[],
46353  size_t const in_edges2[],
46354  size_t in_faces_count,
46355  size_t const in_faces[],
46356  bool in_remove_existing = true);
46357 
46370  HighlightControl & Highlight(
46371  Key const & in_item,
46372  HighlightOptionsKit const & in_options,
46373  size_t in_vertices_count,
46374  size_t const in_vertices[],
46375  size_t in_edges_count,
46376  size_t const in_edges1[],
46377  size_t const in_edges2[],
46378  size_t in_faces_count,
46379  size_t const in_faces[],
46380  bool in_remove_existing = true);
46381 
46386  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
46387 
46392  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
46393 
46398  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
46399 
46404  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
46405 
46410  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
46411 
46420  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces);
46421 
46430  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options, SizeTArray const & in_vertices, SizeTArray const & in_edges1, SizeTArray const & in_edges2, SizeTArray const & in_faces);
46431 
46443  HighlightControl & Unhighlight(
46444  KeyPath const & in_item,
46445  HighlightOptionsKit const & in_options,
46446  size_t in_vertices_count,
46447  size_t const in_vertices[],
46448  size_t in_edges_count,
46449  size_t const in_edges1[],
46450  size_t const in_edges2[],
46451  size_t in_faces_count,
46452  size_t const in_faces[]);
46453 
46465  HighlightControl & Unhighlight(
46466  Key const & in_item,
46467  HighlightOptionsKit const & in_options,
46468  size_t in_vertices_count,
46469  size_t const in_vertices[],
46470  size_t in_edges_count,
46471  size_t const in_edges1[],
46472  size_t const in_edges2[],
46473  size_t in_faces_count,
46474  size_t const in_faces[]);
46475 
46479  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
46480 
46483  HighlightControl & UnhighlightEverything();
46484 
46489  void ShowHighlightState(
46490  Key const & in_key,
46491  HighlightSearchOptionsKit const & in_search_options,
46492  HighlightState & out_state) const;
46493 
46498  void ShowHighlightState(
46499  KeyPath const & in_key_path,
46500  HighlightSearchOptionsKit const & in_search_options,
46501  HighlightState & out_state) const;
46502 
46507  void ShowHighlightStates(
46508  KeyArray const & in_keys,
46509  HighlightSearchOptionsKit const & in_search_options,
46510  HighlightStateArray & out_states) const;
46511 
46516  void ShowHighlightStates(
46517  KeyPathArray const & in_key_paths,
46518  HighlightSearchOptionsKit const & in_search_options,
46519  HighlightStateArray & out_states) const;
46520 
46521 private:
46523  HighlightControl();
46524 };
46525 
46527 class HPS_API UpdateOptionsKit : public Kit
46528 {
46529 public:
46531  UpdateOptionsKit();
46532 
46535  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
46536 
46540  UpdateOptionsKit(UpdateOptionsKit && in_that);
46541 
46545  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
46546 
46547  virtual ~UpdateOptionsKit();
46548 
46549  static const HPS::Type staticType = HPS::Type::UpdateOptionsKit;
46550  HPS::Type ObjectType() const {return staticType;};
46551 
46555  static UpdateOptionsKit GetDefault();
46556 
46559  void Set(UpdateOptionsKit const & in_kit);
46560 
46563  void Show(UpdateOptionsKit & out_kit) const;
46564 
46568  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
46569 
46572  bool Empty() const;
46573 
46577  bool Equals(UpdateOptionsKit const & in_kit) const;
46578 
46582  bool operator==(UpdateOptionsKit const & in_kit) const;
46583 
46587  bool operator!=(UpdateOptionsKit const & in_kit) const;
46588 
46592  UpdateOptionsKit & SetUpdateType(HPS::Window::UpdateType in_type);
46593 
46597  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
46598 
46601  UpdateOptionsKit & UnsetUpdateType();
46602 
46605  UpdateOptionsKit & UnsetTimeLimit();
46606 
46609  UpdateOptionsKit & UnsetEverything();
46610 
46611 
46615  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
46616 
46620  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
46621 
46622 };
46623 
46624 
46625 
46631 class HPS_API UpdateOptionsControl : public Control
46632 {
46633 public:
46636  explicit UpdateOptionsControl(WindowKey const & in_window);
46637 
46640  UpdateOptionsControl(UpdateOptionsControl const & in_that);
46641 
46646 
46650  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
46651 
46653 
46654  virtual HPS::Type Type() const { return ObjectType(); }
46655 
46656  static const HPS::Type staticType = HPS::Type::UpdateOptionsControl;
46657  HPS::Type ObjectType() const {return staticType;};
46658 
46662  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
46663 
46667  UpdateOptionsControl & SetUpdateType(HPS::Window::UpdateType in_type);
46668 
46672  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
46673 
46677  UpdateOptionsControl & UnsetUpdateType();
46678 
46682  UpdateOptionsControl & UnsetTimeLimit();
46683 
46687  UpdateOptionsControl & UnsetEverything();
46688 
46692  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
46693 
46697  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
46698 
46699 private:
46702 };
46703 
46706 class HPS_API World : public Object
46707 {
46708 public:
46715  World(char const * in_license, char const * in_code_generation_directory = nullptr);
46716 
46718  ~World();
46719 
46720  static const HPS::Type staticType = HPS::Type::World;
46721  HPS::Type ObjectType() const {return staticType;};
46722 
46727  World & SetMaterialLibraryDirectory(char const * in_directory);
46728 
46733  World & SetFontDirectory(char const * in_directory);
46734 
46740  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
46741 
46746  World & SetFontDirectories(UTF8Array const & in_directories);
46747 
46753  World & SetDriverConfigFile(char const * in_filename);
46754 
46760  World & SetExchangeLibraryDirectory(char const * in_directory);
46761 
46767  World & SetPublishResourceDirectory(char const * in_directory);
46768 
46774  World & SetParasolidSchemaDirectory(char const * in_directory);
46775 
46781  World & SetParasolidBodyshopDirectory(char const * in_directory);
46782 
46785  World & UnsetMaterialLibraryDirectory();
46786 
46789  World & UnsetFontDirectories();
46790 
46793  World & UnsetDriverConfigFile();
46794 
46797  World & UnsetExchangeLibraryDirectory();
46798 
46801  World & UnsetPublishResourceDirectory();
46802 
46805  World & UnsetParasolidSchemaDirectory();
46806 
46809  World & UnsetParasolidBodyshopDirectory();
46810 
46814  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
46815 
46819  bool ShowFontDirectories(UTF8Array & out_directories) const;
46820 
46824  bool ShowDriverConfigFile(UTF8 & out_filename) const;
46825 
46829  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
46830 
46834  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
46835 
46839  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
46840 
46844  bool ShowParasolidBodyshopDirectory(UTF8 & out_directory) const;
46845 
46849  static void AddCodeGenerationComment(UTF8 const & in_comment);
46850 
46852  static void StopCodeGeneration();
46853 
46854 private:
46856  World();
46857 
46859  virtual void Reset() {}
46860 };
46861 
46862 
46874 class HPS_API EmergencyHandler
46875 {
46876 public:
46877 
46880 
46881  virtual ~EmergencyHandler();
46882 
46884  intptr_t GetClassID() const;
46885 
46890  virtual void Handle(char const * message, HPS::Emergency::Code code) = 0;
46891 
46892  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
46893  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
46894 };
46895 
46896 
46899 class HPS_API Database
46900 {
46901 public:
46906  static void Execute(bool in_once=true);
46907 
46910  static Time GetTime();
46911 
46913  static void Sleep(Time milliseconds);
46914 
46939  static void RelinquishMemory();
46940 
46941 
46967  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
46968 
46976  static void Reset();
46977 
46979  static void Synchronize();
46980 
46983  static WindowKeyArray GetWindowKeys();
46984 
46987  static SegmentKeyArray GetRootSegments();
46988 
46991  static PortfolioKeyArray GetPortfolios();
46992 
46997  static PortfolioKey const GetMaterialLibraryPortfolio();
46998 
47004  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
47005 
47010  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
47011 
47012 #if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
47013 
47017  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
47018 
47023  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
47024 #endif
47025 
47032  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
47033 
47039  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
47040 
47046  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
47047 
47052  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
47053 
47056  static SegmentKey CreateRootSegment();
47057 
47060  static PortfolioKey CreatePortfolio();
47061 
47064  static EventDispatcher CreateEventDispatcher();
47065 
47069  static EventDispatcher CreateEventDispatcher(char const * in_name);
47070 
47076  static size_t SelectByShell(ShellKit const & in_shell,
47077  SelectionOptionsKit const & in_options,
47078  SelectionResults & out_results);
47079 
47085  static size_t SelectByShell(ShellKey const & in_shell,
47086  SelectionOptionsKit const & in_options,
47087  SelectionResults & out_results);
47088 
47095  static size_t SelectByVolume(SimpleCuboid const & in_volume,
47096  SelectionOptionsKit const & in_options,
47097  SelectionResults & out_results);
47098 
47105  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
47106  SelectionOptionsKit const & in_options,
47107  SelectionResults & out_results);
47108 
47111  static EventDispatcher const & GetEventDispatcher();
47112 
47113 
47117  static bool GetInformationEventFilter(HPS::Info::Code in_code);
47118 
47122  static bool GetWarningEventFilter(HPS::Info::Code in_code);
47123 
47127  static bool GetErrorEventFilter(HPS::Info::Code in_code);
47128 
47133  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
47134 
47139  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
47140 
47145  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
47146 
47147 
47150  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
47151 
47153  static void UnsetEmergencyHandler();
47154 
47157  static size_t GetSoftMemoryLimit();
47158 
47162  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
47163 
47166  static size_t GetOOCMemoryLimit();
47167 
47171  static size_t SetOOCMemoryLimit(size_t in_limit_bytes);
47172 
47176  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
47177 
47183  static bool ShowAvailableGPUs(HPS::UTF8Array & out_available_gpus);
47184 
47185 private:
47187  Database();
47188 };
47189 
47190 
47194 
47195 
47196 
47198 class HPS_API EventDispatcher : public Object
47199 {
47200 public:
47203  EventDispatcher();
47204 
47207  EventDispatcher(EventDispatcher const & in_that);
47208 
47212  EventDispatcher(EventDispatcher && in_that);
47213 
47217  EventDispatcher & operator=(EventDispatcher && in_that);
47218 
47219  virtual ~EventDispatcher();
47220 
47221  static const HPS::Type staticType = HPS::Type::EventDispatcher;
47222  HPS::Type ObjectType() const {return staticType;};
47223 
47227  EventDispatcher & operator=(EventDispatcher const & in_that);
47228 
47232  bool Equals(EventDispatcher const & in_that) const;
47233 
47237  bool operator==(EventDispatcher const & in_that) const;
47238 
47242  bool operator!=(EventDispatcher const & in_that) const;
47243 
47248  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
47249 
47254  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
47255 
47260  bool UnSubscribe(EventHandler const & in_handler) const;
47261 
47265  bool UnSubscribe(intptr_t in_type) const;
47266 
47270  bool InjectEvent(Event const & in_event) const;
47271 
47276  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
47277 
47280  void Shutdown() const;
47281 
47284  bool IsShutdown() const;
47285 
47286 
47289  void SetName(char const * in_name) const;
47290 
47293  void ShowName(UTF8 & out_name) const;
47294 
47295 private:
47297  virtual void Reset() {}
47298 };
47299 
47300 
47303 class HPS_API EventHandler : public Object
47304 {
47305 public:
47307  EventHandler();
47308 
47311  EventHandler(EventHandler const & in_that);
47312 
47316  EventHandler(EventHandler && in_that);
47317 
47321  EventHandler & operator=(EventHandler && in_that);
47322 
47326  EventHandler & operator=(EventHandler const & in_that);
47327 
47328  virtual ~EventHandler();
47329 
47330  static const HPS::Type staticType = HPS::Type::EventHandler;
47331  HPS::Type ObjectType() const {return staticType;};
47332 
47337  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
47338 
47343  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
47344 
47348  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
47349 
47351  void UnSubscribeEverything() const;
47352 
47354  virtual void Reset() { UnSubscribeEverything(); }
47355 
47358  void Shutdown();
47359 
47362  enum class HandleResult : uint32_t
47363  {
47364  Handled,
47365  NotHandled
47366  };
47367 
47372  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
47373 };
47374 
47375 
47376 
47378 class HPS_API TimerTickEvent : public Event
47379 {
47380 public:
47383  {
47384  channel = GetClassID();
47385  consumable = false;
47386  }
47387 
47388 
47391  TimerTickEvent(Event const & in_event) : Event(in_event)
47392  {
47393  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
47394  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47395  }
47396 
47397  ~TimerTickEvent();
47398 
47401  Event * Clone() const
47402  {
47403  TimerTickEvent * new_event = new TimerTickEvent(*this);
47404  return new_event;
47405  }
47406 
47410  virtual bool Drop(Event const * in_that_event) const
47411  {
47412  HPS_UNREFERENCED(in_that_event);
47413  return true;
47414  }
47415 
47416  virtual intptr_t Freshen() const {
47417  return GetClassID();
47418  }
47419 };
47420 
47422 class HPS_API HighlightEvent : public Event
47423 {
47424 public:
47425  enum class Action : uint32_t
47426  {
47427  None = 0,
47428  Highlight,
47429  Unhighlight,
47430  };
47431 
47434  {
47435  channel = GetClassID();
47436  consumable = false;
47437  action = Action::None;
47438  }
47439 
47440  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
47441  : Event(), action(in_action), results(in_results), options(in_options)
47442  {
47443  channel = GetClassID();
47444  consumable = false;
47445  }
47446 
47449  HighlightEvent(Event const & in_event) : Event(in_event)
47450  {
47451  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
47452  {
47453  auto that = static_cast<HighlightEvent const &>(in_event);
47454  action = that.action;
47455  results = that.results;
47456  options = that.options;
47457  }
47458  else
47459  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47460  }
47461 
47462  ~HighlightEvent();
47463 
47466  Event * Clone() const
47467  {
47468  HighlightEvent * new_event = new HighlightEvent(*this);
47469  return new_event;
47470  }
47471 
47472  Action action;
47473  SelectionResults results;
47474  HighlightOptionsKit options;
47475 };
47476 
47478 class HPS_API InformationEvent : public Event
47479 {
47480 public:
47482  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
47483 
47486  InformationEvent(char const * in_message);
47487 
47491  InformationEvent(char const * in_message, HPS::Info::Code in_code);
47492 
47495  InformationEvent(Event const & in_event) : Event(in_event)
47496  {
47497  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
47498  {
47499  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
47500  message = event->message;
47501  code = event->code;
47502  }
47503  else
47504  {
47505  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47506  }
47507  }
47508 
47509  ~InformationEvent();
47510 
47513  Event * Clone() const
47514  {
47515  InformationEvent * new_event = new InformationEvent(*this);
47516  return new_event;
47517  }
47518 
47522  virtual bool Equals(InformationEvent const & in_that) const
47523  {
47524  return message == in_that.message && code == in_that.code;
47525  }
47526 
47530  virtual bool operator== (InformationEvent const & in_that) const
47531  {
47532  return Equals(in_that);
47533  }
47534 
47538  virtual bool operator!= (InformationEvent const & in_that) const
47539  {
47540  return !Equals(in_that);
47541  }
47542 
47545 };
47546 
47547 
47549 class HPS_API WarningEvent : public Event
47550 {
47551 public:
47553  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
47554 
47557  WarningEvent(char const * in_message);
47558 
47562  WarningEvent(char const * in_message, HPS::Info::Code in_code);
47563 
47566  WarningEvent(Event const & in_event) : Event(in_event)
47567  {
47568  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
47569  {
47570  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
47571  message = event->message;
47572  code = event->code;
47573  }
47574  else
47575  {
47576  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47577  }
47578  }
47579 
47580  ~WarningEvent();
47581 
47584  Event * Clone() const
47585  {
47586  WarningEvent * new_event = new WarningEvent(*this);
47587  return new_event;
47588  }
47589 
47593  virtual bool Equals(WarningEvent const & in_that) const
47594  {
47595  return message == in_that.message && code == in_that.code;
47596  }
47597 
47601  virtual bool operator== (WarningEvent const & in_that) const
47602  {
47603  return Equals(in_that);
47604  }
47605 
47609  virtual bool operator!= (WarningEvent const & in_that) const
47610  {
47611  return !Equals(in_that);
47612  }
47613 
47616 };
47617 
47618 
47620 class HPS_API ErrorEvent : public Event
47621 {
47622 public:
47624  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
47625 
47628  ErrorEvent(char const * in_message);
47629 
47633  ErrorEvent(char const * in_message, HPS::Info::Code in_code);
47634 
47637  ErrorEvent(Event const & in_event) : Event(in_event)
47638  {
47639  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
47640  {
47641  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
47642  message = event->message;
47643  code = event->code;
47644  }
47645  else
47646  {
47647  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47648  }
47649  }
47650 
47651  ~ErrorEvent();
47652 
47655  Event * Clone() const
47656  {
47657  ErrorEvent * new_event = new ErrorEvent(*this);
47658  return new_event;
47659  }
47660 
47664  virtual bool Equals(ErrorEvent const & in_that) const
47665  {
47666  return message == in_that.message && code == in_that.code;
47667  }
47668 
47672  virtual bool operator== (ErrorEvent const & in_that) const
47673  {
47674  return Equals(in_that);
47675  }
47676 
47680  virtual bool operator!= (ErrorEvent const & in_that) const
47681  {
47682  return !Equals(in_that);
47683  }
47684 
47687 };
47688 
47689 
47690 #if TARGET_OS_ANDROID == 0 && !defined(__APPLE__)
47691 
47692 class HPS_API StandAloneWindowEvent : public Event
47693 {
47694 public:
47695 
47698  enum class Action : uint32_t
47699  {
47700  Unknown,
47701  Close,
47702  FocusIn,
47703  FocusOut,
47704  };
47705 
47707  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
47708 
47709 
47712  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
47713 
47716  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
47717  {
47718  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
47719  {
47720  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
47721  action = event->action;
47722  }
47723  else
47724  {
47725  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47726  }
47727  }
47728 
47730 
47733  Event * Clone() const
47734  {
47735  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
47736  return new_event;
47737  }
47738 
47742  virtual bool Equals(StandAloneWindowEvent const & in_that) const
47743  {
47744  return action == in_that.action;
47745  }
47746 
47750  virtual bool operator== (StandAloneWindowEvent const & in_that) const
47751  {
47752  return Equals(in_that);
47753  }
47754 
47758  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
47759  {
47760  return !Equals(in_that);
47761  }
47762 
47764 };
47765 #endif
47766 
47768 class HPS_API FocusLostEvent : public Event
47769 {
47770 public:
47773  Event()
47774  { channel = GetClassID(); }
47775 
47776  ~FocusLostEvent();
47777 
47780  Event * Clone() const
47781  {
47782  FocusLostEvent * new_event = new FocusLostEvent(*this);
47783  return new_event;
47784  }
47785 };
47786 
47788 class HPS_API TextInputEvent : public Event
47789 {
47790  public:
47793  Event()
47794  { channel = GetClassID(); }
47795 
47798  TextInputEvent(char const * in_text) : Event(), text(in_text, "utf8") { channel = GetClassID(); }
47799 
47802  TextInputEvent(Event const & in_event) : Event(in_event)
47803  {
47804  if(in_event.GetChannel() == Object::ClassID<TextInputEvent>())
47805  {
47806  TextInputEvent const * event = static_cast<TextInputEvent const *>(&in_event);
47807  text = event->text;
47808  }
47809  else
47810  {
47811  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47812  }
47813  }
47814 
47818  virtual bool Equals(TextInputEvent const & in_that) const
47819  {
47820  return text == in_that.text;
47821  }
47822 
47826  virtual bool operator== (TextInputEvent const & in_that) const
47827  {
47828  return Equals(in_that);
47829  }
47830 
47834  virtual bool operator!= (ErrorEvent const & in_that) const
47835  {
47836  return !Equals(in_that);
47837  }
47838 
47839  ~TextInputEvent();
47840 
47843  Event * Clone() const
47844  {
47845  TextInputEvent * new_event = new TextInputEvent(*this);
47846  return new_event;
47847  }
47848 
47850 };
47851 
47852 
47857 class HPS_API UpdateCompletedEvent : public Event
47858 {
47859 public:
47861  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
47862 
47864  UpdateCompletedEvent(Time in_update_time, Window::UpdateStatus in_update_status) : Event(), update_time(in_update_time), update_status(in_update_status) { channel = GetClassID(); }
47865 
47868  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
47869  {
47870  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
47871  {
47872  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
47873  update_time = event->update_time;
47874  update_status = event->update_status;
47875  }
47876  else
47877  {
47878  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47879  }
47880  }
47881 
47882  virtual ~UpdateCompletedEvent();
47883 
47886  Event * Clone() const
47887  {
47888  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
47889  return new_event;
47890  }
47891 
47892  Time update_time;
47893  Window::UpdateStatus update_status;
47894 };
47895 
47897 class HPS_API ImportStatusEvent : public Event
47898 {
47899 public:
47902  : Event()
47903  { channel = GetClassID(); }
47904 
47905  ImportStatusEvent(char const * in_message)
47906  : Event()
47907  , import_status_message(in_message, "utf8")
47908  { channel = GetClassID(); }
47909 
47912  ImportStatusEvent(Event const & in_event) : Event(in_event)
47913  {
47914  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
47915  {
47916  auto event = static_cast<ImportStatusEvent const &>(in_event);
47917  import_status_message = event.import_status_message;
47918  }
47919  else
47920  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47921  }
47922 
47923  ~ImportStatusEvent();
47924 
47927  Event * Clone() const
47928  {
47929  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
47930  return new_event;
47931  }
47932 
47933  HPS::UTF8 import_status_message;
47934 };
47935 
47937 class HPS_API ShowKeyboardEvent : public Event
47938 {
47939 public:
47942  : Event()
47943  { channel = GetClassID(); }
47944 
47947  ShowKeyboardEvent(Event const & in_event) : Event(in_event)
47948  {
47949  if (in_event.GetChannel() != Object::ClassID<ShowKeyboardEvent>())
47950  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47951  }
47952 
47953  ~ShowKeyboardEvent();
47954 
47957  Event * Clone() const
47958  {
47959  ShowKeyboardEvent * new_event = new ShowKeyboardEvent(*this);
47960  return new_event;
47961  }
47962 
47963 };
47964 
47966 class HPS_API HideKeyboardEvent : public Event
47967 {
47968 public:
47971  : Event()
47972  { channel = GetClassID(); }
47973 
47976  HideKeyboardEvent(Event const & in_event) : Event(in_event)
47977  {
47978  if (in_event.GetChannel() != Object::ClassID<HideKeyboardEvent>())
47979  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
47980  }
47981 
47982  ~HideKeyboardEvent();
47983 
47986  Event * Clone() const
47987  {
47988  HideKeyboardEvent * new_event = new HideKeyboardEvent(*this);
47989  return new_event;
47990  }
47991 
47992 };
47993 
47995 class HPS_API ModifierKeys
47996 {
47997 public:
47999  ModifierKeys() : modifiers(_key_none) {}
48000 
48004  bool Equals(ModifierKeys const & in_that) const
48005  {
48006  return modifiers == in_that.modifiers;
48007  }
48008 
48012  bool operator== (ModifierKeys const & in_that) const
48013  {
48014  return Equals(in_that);
48015  }
48016 
48020  bool operator!= (ModifierKeys const & in_that) const
48021  {
48022  return !Equals(in_that);
48023  }
48024 
48027  bool None() const { return modifiers == _key_none; }
48028 
48031  bool Shift() const { return (modifiers & _key_shift) != 0; }
48032 
48035  bool Control() const { return (modifiers & _key_control) != 0; }
48036 
48039  bool Alt() const { return (modifiers & _key_alt) != 0; }
48040 
48043  bool Meta() const { return (modifiers & _key_meta) != 0; }
48044 
48047  bool CapsLock() const {return (modifiers & _key_caps_lock) != 0; }
48048 
48051  bool NumLock() const {return (modifiers & _key_num_lock) != 0; }
48052 
48055  bool ScrollLock() const {return (modifiers & _key_scroll_lock) != 0; }
48056 
48059  bool RightShift() const {return (modifiers & _key_right_shift) != 0; }
48060 
48063  bool LeftShift() const {return (modifiers & _key_left_shift) != 0; }
48064 
48067  bool RightControl() const {return (modifiers & _key_right_control) != 0; }
48068 
48071  bool LeftControl() const {return (modifiers & _key_left_control) != 0; }
48072 
48075  bool RightAlt() const {return (modifiers & _key_right_alt) != 0; }
48076 
48079  bool LeftAlt() const {return (modifiers & _key_left_alt) != 0; }
48080 
48083  bool RightMeta() const {return (modifiers & _key_right_meta) != 0; }
48084 
48087  bool LeftMeta() const {return (modifiers & _key_left_meta) != 0; }
48088 
48092  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
48093 
48097  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
48098 
48099 
48102  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
48103 
48106  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
48107 
48110  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
48111 
48114  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
48115 
48118  void CapsLock(bool in_state) { if (in_state) modifiers |= _key_caps_lock; else modifiers &= ~(_key_caps_lock); }
48119 
48122  void NumLock(bool in_state) { if (in_state) modifiers |= _key_num_lock; else modifiers &= ~(_key_num_lock); }
48123 
48126  void ScrollLock(bool in_state) { if (in_state) modifiers |= _key_scroll_lock; else modifiers &= ~(_key_scroll_lock); }
48127 
48130  void RightShift(bool in_state) { if (in_state) modifiers |= _key_right_shift; else modifiers &= ~(_key_right_shift); }
48131 
48134  void LeftShift(bool in_state) { if (in_state) modifiers |= _key_left_shift; else modifiers &= ~(_key_left_shift); }
48135 
48138  void RightControl(bool in_state) { if (in_state) modifiers |= _key_right_control; else modifiers &= ~(_key_right_control); }
48139 
48142  void LeftControl(bool in_state) { if (in_state) modifiers |= _key_left_control; else modifiers &= ~(_key_left_control); }
48143 
48146  void RightAlt(bool in_state) { if (in_state) modifiers |= _key_right_alt; else modifiers &= ~(_key_right_alt); }
48147 
48150  void LeftAlt(bool in_state) { if (in_state) modifiers |= _key_left_alt; else modifiers &= ~(_key_left_alt); }
48151 
48154  void RightMeta(bool in_state) { if (in_state) modifiers |= _key_right_meta; else modifiers &= ~(_key_right_meta); }
48155 
48158  void LeftMeta(bool in_state) { if (in_state) modifiers |= _key_left_meta; else modifiers &= ~(_key_left_meta); }
48159 
48163  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
48164  {
48165  ModifierKeys ret;
48166  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
48167  return ret;
48168  }
48169 
48173  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
48174  {
48175  ModifierKeys ret;
48176  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
48177  return ret;
48178  }
48179 
48183  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
48184 
48188  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
48189 
48190 
48194  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
48195 
48199  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
48200 
48204  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
48205 
48209  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
48210 
48213  static ModifierKeys KeyCapsLock() { ModifierKeys ret; ret.CapsLock(true); return ret; }
48214 
48217  static ModifierKeys KeyNumLock() { ModifierKeys ret; ret.NumLock(true); return ret; }
48218 
48221  static ModifierKeys KeyScrollLock() { ModifierKeys ret; ret.ScrollLock(true); return ret; }
48222 
48225  static ModifierKeys KeyRightShift() { ModifierKeys ret; ret.RightShift(true); return ret; }
48226 
48229  static ModifierKeys KeyLeftShift() { ModifierKeys ret; ret.LeftShift(true); return ret; }
48230 
48233  static ModifierKeys KeyRightControl() { ModifierKeys ret; ret.RightControl(true); return ret; }
48234 
48237  static ModifierKeys KeyLeftControl() { ModifierKeys ret; ret.LeftControl(true); return ret; }
48238 
48241  static ModifierKeys KeyRightAlt() { ModifierKeys ret; ret.RightAlt(true); return ret; }
48242 
48245  static ModifierKeys KeyLeftAlt() { ModifierKeys ret; ret.LeftAlt(true); return ret; }
48246 
48249  static ModifierKeys KeyRightMeta() { ModifierKeys ret; ret.RightMeta(true); return ret; }
48250 
48253  static ModifierKeys KeyLeftMeta() { ModifierKeys ret; ret.LeftMeta(true); return ret; }
48254 
48255 protected:
48256 
48260  {
48261  _key_none = 0x0000,
48262  _key_caps_lock = 0x0001,
48263  _key_num_lock = 0x0002,
48264  _key_scroll_lock = 0x0004,
48265  _key_right_shift = 0x0008,
48266  _key_left_shift = 0x0010,
48267  _key_right_control = 0x0020,
48268  _key_left_control = 0x0040,
48269  _key_right_alt = 0x0080,
48270  _key_left_alt = 0x0100,
48271  _key_right_meta = 0x0200,
48272  _key_left_meta = 0x0400,
48273  _key_shift = _key_left_shift | _key_right_shift,
48274  _key_control = _key_left_control | _key_right_control,
48275  _key_alt = _key_left_alt | _key_right_alt,
48276  _key_meta = _key_left_meta | _key_right_meta,
48277  };
48278 
48279  int modifiers;
48280 };
48281 
48282 
48285 class HPS_API InputEvent : public Event
48286 {
48287 public:
48288 
48290  InputEvent() : Event() { channel = GetClassID(); }
48291 
48294  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
48295 
48296  ~InputEvent();
48297 
48300  Event * Clone() const
48301  {
48302  InputEvent * new_event = new InputEvent(*this);
48303  return new_event;
48304  }
48305 
48309  virtual bool Equals(InputEvent const & in_that) const
48310  {
48311  if ( GetClassID() == in_that.GetClassID())
48312  return ModifierKeyState == in_that.ModifierKeyState;
48313  return false;
48314  }
48315 
48319  virtual bool operator== (InputEvent const & in_that) const
48320  {
48321  return Equals(in_that);
48322  }
48323 
48327  virtual bool operator!= (InputEvent const & in_that) const
48328  {
48329  return !Equals(in_that);
48330  }
48331 
48335  {
48336  return ModifierKeyState;
48337  }
48338 
48340 };
48341 
48343 class HPS_API TouchEvent : public InputEvent
48344 {
48345 public:
48348  enum class Action : uint32_t
48349  {
48350  TouchDown,
48351  TouchUp,
48352  Move,
48353  };
48354 
48356  TouchEvent() : InputEvent() { channel = GetClassID(); }
48357 
48362  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
48363  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
48364 
48370  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
48371  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
48372 
48379  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
48380  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
48381 
48382 
48385  TouchEvent(Event const & in_event) : InputEvent()
48386  {
48387  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
48388  {
48389  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
48390  channel = GetClassID();
48391  CurrentAction = event->CurrentAction;
48392  Touches = event->Touches;
48393  ModifierKeyState = event->ModifierKeyState;
48394  }
48395  else
48396  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
48397  }
48398 
48399  ~TouchEvent();
48400 
48401 
48404  Event * Clone() const
48405  {
48406  TouchEvent * new_event = new TouchEvent(*this);
48407  return new_event;
48408  }
48409 
48413  virtual bool Equals(InputEvent const & in_that) const
48414  {
48415  if (GetClassID() == in_that.GetClassID())
48416  return Equals(static_cast<TouchEvent>(in_that));
48417  return false;
48418  }
48419 
48423  bool Equals(TouchEvent const & in_that) const
48424  {
48425  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
48426  }
48427 
48431  virtual bool operator== (TouchEvent const & in_that) const
48432  {
48433  return Equals(in_that);
48434  }
48435 
48439  virtual bool operator!= (TouchEvent const & in_that) const
48440  {
48441  return !Equals(in_that);
48442  }
48443 
48447  virtual bool Drop(Event const * in_that_event) const
48448  {
48449  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
48450 
48451  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
48452  && Touches.size() == that_touch_event->Touches.size() )
48453  {
48454  TouchArray these_touches = Touches;
48455  TouchArray those_touches = that_touch_event->Touches;
48456 
48457  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
48458  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
48459 
48460  for (size_t i = 0 ; i < these_touches.size() ; i++)
48461  {
48462  if (these_touches[i].ID != those_touches[i].ID)
48463  return false;
48464  }
48465  return true;
48466  }
48467 
48468  return false;
48469  }
48470 
48473 
48474 private:
48480  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
48481  {
48482  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
48483  }
48484 };
48485 
48486 
48488 class HPS_API MouseButtons
48489 {
48490 public:
48492  MouseButtons() : buttons(_button_none) {}
48493 
48497  bool Equals(MouseButtons const & in_that) const
48498  {
48499  return buttons == in_that.buttons;
48500  }
48501 
48505  bool operator== (MouseButtons const & in_that) const
48506  {
48507  return Equals(in_that);
48508  }
48509 
48513  bool operator!= (MouseButtons const & in_that) const
48514  {
48515  return !Equals(in_that);
48516  }
48517 
48520  bool None() const { return buttons == _button_none; }
48521 
48524  bool Left() const { return (buttons & _button_left) != 0; }
48525 
48528  bool Right() const { return (buttons & _button_right) != 0; }
48529 
48532  bool Middle() const { return (buttons & _button_middle) != 0; }
48533 
48536  bool X1() const { return (buttons & _button_x1) != 0; }
48537 
48540  bool X2() const { return (buttons & _button_x2) != 0; }
48541 
48542 
48546  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
48547 
48551  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
48552 
48555  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
48556 
48559  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
48560 
48563  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
48564 
48567  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
48568 
48571  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
48572 
48576  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
48577  {
48578  MouseButtons ret;
48579  ret.buttons = buttons | in_buttons_to_merge.buttons;
48580  return ret;
48581  }
48582 
48586  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
48587  {
48588  MouseButtons ret;
48589  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
48590  return ret;
48591  }
48592 
48596  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
48597 
48601  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
48602 
48603 
48606  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
48607 
48610  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
48611 
48614  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
48615 
48618  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
48619 
48622  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
48623 
48624 protected:
48625 
48628  enum Buttons
48629  {
48630  _button_none = 0x0000,
48631  _button_left = 0x0001,
48632  _button_right = 0x0002,
48633  _button_middle = 0x0004,
48634  _button_x1 = 0x0008,
48635  _button_x2 = 0x0010
48636  };
48637 
48638  int buttons;
48639 };
48640 
48642 class HPS_API MouseEvent : public InputEvent
48643 {
48644 public:
48645 
48648  enum class Action : uint32_t
48649  {
48650  ButtonUp,
48651  ButtonDown,
48652  Move,
48653  Scroll,
48654  Enter,
48655  Leave
48656  };
48657 
48659  MouseEvent() : InputEvent() { channel = GetClassID(); }
48660 
48667  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
48668  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
48669 
48677  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)
48678  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
48679 
48682  MouseEvent(Event const & in_event) : InputEvent()
48683  {
48684  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
48685  {
48686  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
48687  channel = GetClassID();
48688  CurrentAction = event->CurrentAction;
48689  Location = event->Location;
48690  CurrentButton = event->CurrentButton;
48691  WheelDelta = event->WheelDelta;
48692  ClickCount = event->ClickCount;
48693  }
48694  else
48695  {
48696  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
48697  }
48698  }
48699 
48700  ~MouseEvent();
48701 
48704  Event * Clone() const
48705  {
48706  MouseEvent * new_event = new MouseEvent(*this);
48707  return new_event;
48708  }
48709 
48713  virtual bool Equals(InputEvent const & in_that) const
48714  {
48715  if (GetClassID() == in_that.GetClassID())
48716  return Equals(static_cast<MouseEvent>(in_that));
48717  return false;
48718  }
48719 
48723  virtual bool Equals(MouseEvent const & in_that) const
48724  {
48725  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
48726  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
48727  && Location == in_that.Location && ClickCount == in_that.ClickCount;
48728  }
48729 
48733  virtual bool operator== (MouseEvent const & in_that) const
48734  {
48735  return Equals(in_that);
48736  }
48737 
48741  virtual bool operator!= (MouseEvent const & in_that) const
48742  {
48743  return !Equals(in_that);
48744  }
48745 
48749  virtual bool Drop(Event const * in_that_event) const
48750  {
48751  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
48752 
48753  if (CurrentAction == that_mouse_event->CurrentAction &&
48754  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
48755  CurrentButton == that_mouse_event->CurrentButton)
48756  return true;
48757 
48758  return false;
48759  }
48760 
48761  virtual intptr_t Freshen() const {
48762 
48763  if (CurrentAction == Action::Move)
48764  return GetClassID();
48765 
48766  return 0;
48767  }
48768 
48772  float WheelDelta;
48773  size_t ClickCount;
48774 };
48775 
48776 
48778 class HPS_API KeyboardEvent : public InputEvent
48779 {
48780 public:
48783  enum class Action : uint32_t
48784  {
48785  None,
48786  KeyDown,
48787  KeyUp
48788  };
48789 
48791  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
48792 
48797  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
48798 
48804  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
48805  : InputEvent(in_modifiers), CurrentAction(in_action)
48806  {
48807  channel = GetClassID();
48808  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
48809  }
48810 
48815  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
48816  : InputEvent(in_modifiers), CurrentAction(in_action)
48817  {
48818  channel = GetClassID();
48819  KeyboardCodes = in_keyboardcodes;
48820  }
48821 
48824  KeyboardEvent(Event const & in_event) : InputEvent()
48825  {
48826  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
48827  {
48828  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
48829  channel = GetClassID();
48830  KeyboardCodes = event->KeyboardCodes;
48831  CurrentAction = event->CurrentAction;
48832  }
48833  else
48834  {
48835  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
48836  }
48837  }
48838 
48839  ~KeyboardEvent();
48840 
48843  Event * Clone() const
48844  {
48845  KeyboardEvent * new_event = new KeyboardEvent(*this);
48846  return new_event;
48847  }
48848 
48852  virtual bool Equals(InputEvent const & in_that) const
48853  {
48854  if (GetClassID() == in_that.GetClassID())
48855  return Equals(static_cast<KeyboardEvent>(in_that));
48856  return false;
48857  }
48858 
48862  virtual bool Equals(KeyboardEvent const & in_that) const
48863  {
48864  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
48865  }
48866 
48870  virtual bool operator== (KeyboardEvent const & in_that) const
48871  {
48872  return Equals(in_that);
48873  }
48874 
48878  virtual bool operator!= (KeyboardEvent const & in_that) const
48879  {
48880  return !Equals(in_that);
48881  }
48882 
48886  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
48887  {
48888  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
48889  }
48890 
48893  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
48894  {
48895  KeyboardCodes = in_keyboardcodes;
48896  }
48897 
48900 };
48901 
48902 
48904 class HPS_API MouseState : public Object
48905 {
48906 public:
48908  MouseState();
48909 
48912  MouseState(MouseState const & in_that);
48913 
48917  MouseState(MouseState && in_that);
48918 
48922  MouseState & operator=(MouseState && in_that);
48923 
48924  ~MouseState();
48925 
48926  static const HPS::Type staticType = HPS::Type::MouseState;
48927  HPS::Type ObjectType() const {return staticType;};
48928 
48931  void Assign(MouseState const & in_that);
48932 
48936  MouseState & operator=(MouseState const & in_that);
48937 
48941  bool Equals(MouseState const & in_that) const;
48942 
48946  bool operator== (MouseState const & in_that) const;
48947 
48951  bool operator!= (MouseState const & in_that) const;
48952 
48957  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
48958 
48965  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
48966 
48969  HPS::MouseEvent GetActiveEvent() const;
48970 
48974  HPS::WindowKey GetEventSource() const;
48975 
48979  HPS::KeyArray GetEventPath() const;
48980 
48983  MouseButtons GetButtons() const;
48984 
48987  WindowPoint GetLocation() const;
48988 
48991  ModifierKeys GetModifierKeys() const;
48992 
48995  void SetActiveEvent(MouseEvent const & in_event);
48996 
48999  void SetEventPath(KeyArray const & in_path);
49000 
49003  void SetButtons(MouseButtons in_buttons);
49004 
49007  void SetLocation(WindowPoint const & in_point);
49008 
49011  void SetModifierKeys(ModifierKeys in_modifiers);
49012 };
49013 
49014 
49015 
49017 class HPS_API TouchState : public Object
49018 {
49019 public:
49021  TouchState();
49022 
49025  TouchState(TouchState const & in_that);
49026 
49030  TouchState(TouchState && in_that);
49031 
49035  TouchState & operator=(TouchState && in_that);
49036 
49037  ~TouchState();
49038 
49039  static const HPS::Type staticType = HPS::Type::TouchState;
49040  HPS::Type ObjectType() const {return staticType;};
49041 
49044  void Assign(TouchState const & in_that);
49045 
49049  TouchState & operator=(TouchState const & in_that);
49050 
49054  bool Equals(TouchState const & in_that) const;
49055 
49059  bool operator== (TouchState const & in_that) const;
49060 
49064  bool operator!= (TouchState const & in_that) const;
49065 
49071  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
49072 
49075  HPS::TouchEvent GetActiveEvent() const;
49076 
49080  HPS::WindowKey GetEventSource() const;
49081 
49085  HPS::KeyArray GetEventPath() const;
49086 
49089  size_t GetTouchCount() const;
49090 
49093  HPS::TouchArray GetTouches() const;
49094 
49097  ModifierKeys GetModifierKeys() const;
49098 
49101  void SetActiveEvent(TouchEvent const & in_event);
49102 
49105  void SetEventPath(KeyArray const & in_path);
49106 
49109  void SetTouches(TouchArray const & in_touches);
49110 
49113  void SetModifierKeys(ModifierKeys in_modifiers);
49114 };
49115 
49116 
49117 
49119 class HPS_API KeyboardState : public Object
49120 {
49121 public:
49123  KeyboardState();
49124 
49127  KeyboardState(KeyboardState const & in_that);
49128 
49132  KeyboardState(KeyboardState && in_that);
49133 
49137  KeyboardState & operator=(KeyboardState && in_that);
49138 
49139  ~KeyboardState();
49140 
49141  static const HPS::Type staticType = HPS::Type::KeyboardState;
49142  HPS::Type ObjectType() const {return staticType;};
49143 
49146  void Assign(KeyboardState const & in_that);
49147 
49151  KeyboardState & operator=(KeyboardState const & in_that);
49152 
49156  bool Equals(KeyboardState const & in_that) const;
49157 
49161  bool operator== (KeyboardState const & in_that) const;
49162 
49166  bool operator!= (KeyboardState const & in_that) const;
49167 
49173  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
49174 
49177  HPS::KeyboardEvent GetActiveEvent() const;
49178 
49182  HPS::WindowKey GetEventSource() const;
49183 
49187  HPS::KeyArray GetEventPath() const;
49188 
49191  size_t GetKeyboardCodeCount() const;
49192 
49195  HPS::KeyboardCodeArray GetKeyboardCodes() const;
49196 
49200  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
49201 
49204  ModifierKeys GetModifierKeys() const;
49205 
49208  void SetActiveEvent(KeyboardEvent const & in_event);
49209 
49212  void SetEventPath(KeyArray const & in_path);
49213 
49216  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
49217 
49220  void SetModifierKeys(ModifierKeys in_modifiers);
49221 };
49222 
49223 
49226 class HPS_API IONotifier : public Object
49227 {
49228 public:
49230  IONotifier();
49231 
49234  IONotifier(IONotifier const & in_that);
49235 
49239  IONotifier(IONotifier && in_that);
49240 
49244  IONotifier & operator=(IONotifier && in_that);
49245 
49246  virtual ~IONotifier();
49247 
49248  static const HPS::Type staticType = HPS::Type::IONotifier;
49249  HPS::Type ObjectType() const {return staticType;};
49250 
49254  IONotifier & operator=(IONotifier const & in_that);
49255 
49258  void Assign(IONotifier const & in_that);
49259 
49262  IONotifier & Wait();
49263 
49266  IOResult Status() const;
49267 
49271  IOResult Status(float & out_percent_complete) const;
49272 
49277  IONotifier & Cancel();
49278 };
49279 
49283 
49285 class HPS_API PointCloud
49286 {
49287 public:
49289 class HPS_API ImportResultsKit : public Kit
49290  {
49291  public:
49293  ImportResultsKit();
49294 
49297  ImportResultsKit(ImportResultsKit const & in_kit);
49298 
49302  ImportResultsKit(ImportResultsKit && in_that);
49303 
49307  ImportResultsKit & operator=(ImportResultsKit && in_that);
49308 
49309  virtual ~ImportResultsKit();
49310 
49311  static const HPS::Type staticType = HPS::Type::PointCloudImportResultsKit;
49312  HPS::Type ObjectType() const { return staticType; };
49313 
49316  void Set(ImportResultsKit const & in_kit);
49317 
49320  void Show(ImportResultsKit & out_kit) const;
49321 
49325  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
49326 
49329  bool Empty() const;
49330 
49334  bool Equals(ImportResultsKit const & in_kit) const;
49335 
49339  bool operator==(ImportResultsKit const & in_kit) const;
49340 
49344  bool operator!=(ImportResultsKit const & in_kit) const;
49345 
49350  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
49351 
49355  ImportResultsKit & UnsetSegment();
49356 
49361  bool ShowSegment(SegmentKey & out_segment) const;
49362 
49365  ImportResultsKit & UnsetEverything();
49366  };
49367 
49369  class HPS_API ImportOptionsKit : public Kit
49370  {
49371  public:
49373  ImportOptionsKit();
49374 
49377  ImportOptionsKit(ImportOptionsKit const & in_kit);
49378 
49382  ImportOptionsKit(ImportOptionsKit && in_that);
49383 
49387  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
49388 
49389  virtual ~ImportOptionsKit();
49390 
49391  static const HPS::Type staticType = HPS::Type::PointCloudImportOptionsKit;
49392  HPS::Type ObjectType() const { return staticType; };
49393 
49396  void Set(ImportOptionsKit const & in_kit);
49397 
49400  void Show(ImportOptionsKit & out_kit) const;
49401 
49405  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
49406 
49409  bool Empty() const;
49410 
49414  bool Equals(ImportOptionsKit const & in_kit) const;
49415 
49419  bool operator==(ImportOptionsKit const & in_kit) const;
49420 
49424  bool operator!=(ImportOptionsKit const & in_kit) const;
49425 
49430  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
49431 
49434  ImportOptionsKit & UnsetSegment();
49435 
49439  bool ShowSegment(SegmentKey & out_segment) const;
49440 
49447  ImportOptionsKit & SetPointColor(RGBColor const & in_color, bool in_override = false);
49448 
49451  ImportOptionsKit & UnsetPointColor();
49452 
49457  bool ShowPointColor(RGBColor & out_color, bool & out_override) const;
49458 
49461  ImportOptionsKit & UnsetEverything();
49462  };
49463 
49464 
49467  class HPS_API ImportNotifier : public IONotifier
49468  {
49469  public:
49471  ImportNotifier();
49472 
49475  ImportNotifier(ImportNotifier const & in_that);
49476 
49481  ImportNotifier(IONotifier const & in_that);
49482 
49486  ImportNotifier(ImportNotifier && in_that);
49487 
49491  ImportNotifier & operator=(ImportNotifier && in_that);
49492 
49493  virtual ~ImportNotifier();
49494 
49495  static const HPS::Type staticType = HPS::Type::PointCloudImportNotifier;
49496  HPS::Type ObjectType() const {return staticType;};
49497 
49501  ImportNotifier & operator=(ImportNotifier const & in_that);
49502 
49505  void Assign(ImportNotifier const & in_that);
49506 
49510  ImportResultsKit GetResults() const;
49511  };
49512 
49513 
49515  class HPS_API File
49516  {
49517  public:
49523  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
49524 
49525  private:
49527  File();
49528  };
49529 private:
49531  PointCloud();
49532 };
49533 
49537 
49539 class HPS_API Stream
49540 {
49541 public:
49542  class ImportNotifier;
49543  class ImportOptionsKit;
49544 
49546  class HPS_API Toolkit : public Object
49547  {
49548  public:
49550  Toolkit();
49551 
49554  Toolkit(Toolkit const & in_toolkit);
49555 
49559  Toolkit(Toolkit && in_toolkit);
49560 
49564  Toolkit & operator=(Toolkit const & in_toolkit);
49565 
49569  Toolkit & operator=(Toolkit && in_toolkit);
49570 
49571  static const HPS::Type staticType = HPS::Type::StreamToolkit;
49572  HPS::Type ObjectType() const { return staticType; }
49573 
49575  virtual void Restart();
49576 
49577  ImportNotifier ParseBuffers(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
49578  };
49579 
49582  static Toolkit CreateToolkit();
49583 
49584 
49585 
49587 
49589  class HPS_API ExportEvent
49590  {
49591  protected:
49592  ExportEvent() {}
49593  public:
49594  virtual ~ExportEvent();
49596  intptr_t GetClassID() const;
49600  };
49601 
49603  class HPS_API ExportEventHandler
49604  {
49605  public:
49606  ExportEventHandler() {}
49607  virtual ~ExportEventHandler();
49611  virtual void Handle(ExportEvent * in_event);
49612  };
49613 
49615 
49617  class HPS_API GeometryExportEvent : public ExportEvent
49618  {
49620  GeometryExportEvent & operator=(GeometryExportEvent const &);
49621  public:
49623  virtual ~GeometryExportEvent();
49624  GeometryExportEvent(HPS::Key & in_key);
49625 
49628  };
49629 
49631  class HPS_API SegmentExportEvent : public ExportEvent
49632  {
49634  SegmentExportEvent & operator=(SegmentExportEvent const &);
49635  public:
49637  virtual ~SegmentExportEvent();
49638  SegmentExportEvent(HPS::SegmentKey & in_segment_key);
49639 
49642  };
49643 
49645 
49648  class HPS_API ExportStartedEvent : public Event
49649  {
49650  public:
49653  {
49654  channel = GetClassID();
49655  consumable = false;
49656  export_started_time = HPS::Database::GetTime();
49657  }
49658 
49661  ExportStartedEvent(Event const & in_event) : Event(in_event)
49662  {
49663  if (in_event.GetChannel() != Object::ClassID<ExportStartedEvent>())
49664  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
49665  else
49666  {
49667  ExportStartedEvent const & that_event = static_cast<ExportStartedEvent const &>(in_event);
49668  export_started_time = that_event.export_started_time;
49669  }
49670  }
49671 
49672  ~ExportStartedEvent();
49673 
49676  Event * Clone() const
49677  {
49678  ExportStartedEvent * new_event = new ExportStartedEvent(*this);
49679  return new_event;
49680  }
49681 
49685  virtual bool Drop(Event const * in_that_event) const
49686  {
49687  HPS_UNREFERENCED(in_that_event);
49688  return true;
49689  }
49690 
49691  virtual intptr_t Freshen() const {
49692  return GetClassID();
49693  }
49694 
49695  HPS::Time export_started_time;
49696  };
49697 
49699 
49701  class HPS_API ImportEvent
49702  {
49703  protected:
49704  ImportEvent() {}
49705  public:
49706  virtual ~ImportEvent();
49708  intptr_t GetClassID() const;
49709  };
49710 
49715  class HPS_API ImportEventHandler
49716  {
49717  public:
49718  ImportEventHandler() {}
49719  virtual ~ImportEventHandler();
49720 
49726  virtual bool Handle(ImportEvent * in_event);
49727  };
49728 
49731  class HPS_API ImportCompletedEvent : public Event
49732  {
49733  public:
49736  {
49737  channel = GetClassID();
49738  consumable = false;
49739  import_completed_time = HPS::Database::GetTime();
49740  }
49741 
49744  ImportCompletedEvent(Event const & in_event) : Event(in_event)
49745  {
49746  if (in_event.GetChannel() != Object::ClassID<ImportCompletedEvent>())
49747  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
49748  else
49749  {
49750  ImportCompletedEvent const & that_event = static_cast<ImportCompletedEvent const &>(in_event);
49751  import_completed_time = that_event.import_completed_time;
49752  }
49753  }
49754 
49756 
49759  Event * Clone() const
49760  {
49761  ImportCompletedEvent * new_event = new ImportCompletedEvent(*this);
49762  return new_event;
49763  }
49764 
49768  virtual bool Drop(Event const * in_that_event) const
49769  {
49770  HPS_UNREFERENCED(in_that_event);
49771  return true;
49772  }
49773 
49774  virtual intptr_t Freshen() const {
49775  return GetClassID();
49776  }
49777 
49778  HPS::Time import_completed_time;
49779  };
49781 
49782  class HPS_API AttributeLockImportEvent : public ImportEvent
49783  {
49786  public:
49788  virtual ~AttributeLockImportEvent();
49789  AttributeLockImportEvent(HPS::SegmentKey & in_segment_key, HPS::AttributeLockKit & in_attribute_lock_kit);
49790 
49791  HPS::SegmentKey & segment_key;
49792  HPS::AttributeLockKit & attribute_lock_kit;
49793  };
49794 
49795  class HPS_API BoundingImportEvent : public ImportEvent
49796  {
49798  BoundingImportEvent & operator=(BoundingImportEvent const &);
49799  public:
49801  virtual ~BoundingImportEvent();
49802  BoundingImportEvent(HPS::SegmentKey & in_segment_key, HPS::BoundingKit & in_bounding_kit);
49803 
49804  HPS::SegmentKey & segment_key;
49805  HPS::BoundingKit & bounding_kit;
49806  };
49807 
49808  class HPS_API CameraImportEvent : public ImportEvent
49809  {
49811  CameraImportEvent & operator=(CameraImportEvent const &);
49812  public:
49814  virtual ~CameraImportEvent();
49815  CameraImportEvent(HPS::SegmentKey & in_segment_key, HPS::CameraKit & in_camera_kit);
49816 
49817  HPS::SegmentKey & segment_key;
49818  HPS::CameraKit & camera_kit;
49819  };
49820 
49821  class HPS_API CircleImportEvent : public ImportEvent
49822  {
49824  CircleImportEvent & operator=(CircleImportEvent const &);
49825  public:
49827  virtual ~CircleImportEvent();
49828  CircleImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircleKit & in_circle_kit);
49829 
49830  HPS::SegmentKey & segment_key;
49831  HPS::CircleKit & circle_kit;
49832  };
49833 
49834  class HPS_API CircularArcImportEvent : public ImportEvent
49835  {
49837  CircularArcImportEvent & operator=(CircularArcImportEvent const &);
49838  public:
49840  virtual ~CircularArcImportEvent();
49841  CircularArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularArcKit & in_circular_arc_kit);
49842 
49843  HPS::SegmentKey & segment_key;
49844  HPS::CircularArcKit & circular_arc_kit;
49845  };
49846 
49847  class HPS_API CircularWedgeImportEvent : public ImportEvent
49848  {
49851  public:
49853  virtual ~CircularWedgeImportEvent();
49854  CircularWedgeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularWedgeKit & in_circular_wedge_kit);
49855 
49856  HPS::SegmentKey & segment_key;
49857  HPS::CircularWedgeKit & circular_wedge_kit;
49858  };
49859 
49861  {
49864  public:
49866  virtual ~ColorInterpolationImportEvent();
49867  ColorInterpolationImportEvent(HPS::SegmentKey & in_segment_key, HPS::ColorInterpolationKit & in_color_interpolation_kit);
49868 
49869  HPS::SegmentKey & segment_key;
49870  HPS::ColorInterpolationKit & color_interpolation_kit;
49871  };
49872 
49873  class HPS_API CommentImportEvent : public ImportEvent
49874  {
49876  CommentImportEvent & operator=(CommentImportEvent const &);
49877  public:
49879  virtual ~CommentImportEvent();
49880  CommentImportEvent(HPS::SegmentKey & in_segment_key, const char* in_comment);
49881 
49882  HPS::SegmentKey & segment_key;
49883  HPS::UTF8 const comment;
49884  };
49885 
49886  class HPS_API ConditionImportEvent : public ImportEvent
49887  {
49889  ConditionImportEvent & operator=(ConditionImportEvent const &);
49890  public:
49892  virtual ~ConditionImportEvent();
49893  ConditionImportEvent(HPS::SegmentKey & in_segment_key);
49894 
49895  HPS::SegmentKey & segment_key;
49896  HPS::UTF8Array conditions;
49897  };
49898 
49899  class HPS_API ContourLineImportEvent : public ImportEvent
49900  {
49902  ContourLineImportEvent & operator=(ContourLineImportEvent const &);
49903  public:
49905  virtual ~ContourLineImportEvent();
49906  ContourLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::ContourLineKit & in_contour_line_kit);
49907 
49908  HPS::SegmentKey & segment_key;
49909  HPS::ContourLineKit & contour_line_kit;
49910  };
49911 
49913  {
49916  public:
49918  virtual ~CuttingSectionImportEvent();
49919  CuttingSectionImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionKit & in_cutting_section_kit);
49920 
49921  HPS::SegmentKey & segment_key;
49922  HPS::CuttingSectionKit & cutting_section_kit;
49923  };
49924 
49926  {
49929  public:
49932  CuttingSectionAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionAttributeKit & in_cutting_section_attribute_kit);
49933 
49934  HPS::SegmentKey & segment_key;
49935  HPS::CuttingSectionAttributeKit & cutting_section_attribute_kit;
49936  };
49937 
49939  {
49942  public:
49944  virtual ~CubeMapDefinitionImportEvent();
49945  CubeMapDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name,
49946  HPS::ImageDefinition & in_negative_z, HPS::ImageDefinition & in_positive_z,
49947  HPS::ImageDefinition & in_negative_x, HPS::ImageDefinition & in_positive_x,
49948  HPS::ImageDefinition & in_negative_y, HPS::ImageDefinition & in_positive_y,
49949  HPS::TextureOptionsKit & in_texture_kit);
49950 
49951  HPS::PortfolioKey & portfolio_key;
49952  UTF8 name;
49953  HPS::ImageDefinition & negative_z;
49954  HPS::ImageDefinition & positive_z;
49955  HPS::ImageDefinition & negative_x;
49956  HPS::ImageDefinition & positive_x;
49957  HPS::ImageDefinition & negative_y;
49958  HPS::ImageDefinition & positive_y;
49959  HPS::TextureOptionsKit & texture_kit;
49960  };
49961 
49962  class HPS_API CullingImportEvent : public ImportEvent
49963  {
49965  CullingImportEvent & operator=(CullingImportEvent const &);
49966  public:
49968  virtual ~CullingImportEvent();
49969  CullingImportEvent(HPS::SegmentKey & in_segment_key, HPS::CullingKit & in_culling_kit);
49970 
49971  HPS::SegmentKey & segment_key;
49972  HPS::CullingKit & culling_kit;
49973  };
49974 
49976  {
49979  public:
49981  virtual ~CurveAttributeImportEvent();
49982  CurveAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CurveAttributeKit & in_curve_attribute_kit);
49983 
49984  HPS::SegmentKey & segment_key;
49985  HPS::CurveAttributeKit & curve_attribute_kit;
49986  };
49987 
49989  {
49992  public:
49994  virtual ~CylinderAttributeImportEvent();
49995  CylinderAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderAttributeKit & in_cylinder_attribute_kit);
49996 
49997  HPS::SegmentKey & segment_key;
49998  HPS::CylinderAttributeKit & cylinder_attribute_kit;
49999  };
50000 
50001  class HPS_API CylinderImportEvent : public ImportEvent
50002  {
50004  CylinderImportEvent & operator=(CylinderImportEvent const &);
50005  public:
50007  virtual ~CylinderImportEvent();
50008  CylinderImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderKit & in_cylinder_kit);
50009 
50010  HPS::SegmentKey & segment_key;
50011  HPS::CylinderKit & cylinder_kit;
50012  };
50013 
50015  {
50018  public:
50021  DistantLightPropertyImportEvent(HPS::DistantLightKey & in_distant_light_key, HPS::DistantLightKit & in_distant_light_kit);
50022 
50023  HPS::DistantLightKey & distant_light_key;
50024  HPS::DistantLightKit & distant_light_kit;
50025  };
50026 
50027  class HPS_API DistantLightImportEvent : public ImportEvent
50028  {
50030  DistantLightImportEvent & operator=(DistantLightImportEvent const &);
50031  public:
50033  virtual ~DistantLightImportEvent();
50034  DistantLightImportEvent(HPS::SegmentKey & in_segment_key, HPS::DistantLightKit & in_distantlight_kit);
50035 
50036  HPS::SegmentKey & segment_key;
50037  HPS::DistantLightKit & distant_light_kit;
50038  };
50039 
50041  {
50044  public:
50046  virtual ~DrawingAttributeImportEvent();
50047  DrawingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::DrawingAttributeKit & in_drawing_attribute_kit);
50048 
50049  HPS::SegmentKey & segment_key;
50050  HPS::DrawingAttributeKit & drawing_attribute_kit;
50051  };
50052 
50053  class HPS_API EdgeAttributeImportEvent : public ImportEvent
50054  {
50057  public:
50059  virtual ~EdgeAttributeImportEvent();
50060  EdgeAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::EdgeAttributeKit & in_edge_attribute_kit);
50061 
50062  HPS::SegmentKey & segment_key;
50063  HPS::EdgeAttributeKit & edge_attribute_kit;
50064  };
50065 
50066  class HPS_API EllipseImportEvent : public ImportEvent
50067  {
50069  EllipseImportEvent & operator=(EllipseImportEvent const &);
50070  public:
50072  virtual ~EllipseImportEvent();
50073  EllipseImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipseKit & in_ellipse_kit);
50074 
50075  HPS::SegmentKey & segment_key;
50076  HPS::EllipseKit & ellipse_kit;
50077  };
50078 
50079  class HPS_API EllipticalArcImportEvent : public ImportEvent
50080  {
50083  public:
50085  virtual ~EllipticalArcImportEvent();
50086  EllipticalArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipticalArcKit & in_elliptical_arc_kit);
50087 
50088  HPS::SegmentKey & segment_key;
50089  HPS::EllipticalArcKit & elliptical_arc_kit;
50090  };
50091 
50093  {
50096  public:
50098  virtual ~GlyphDefinitionImportEvent();
50099  GlyphDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::GlyphKit & in_glyph_kit);
50100 
50101  HPS::PortfolioKey & portfolio_key;
50102  UTF8 name;
50103  HPS::GlyphKit & glyph_kit;
50104  };
50105 
50107  {
50110  public:
50112  virtual ~ShapeDefinitionImportEvent();
50113  ShapeDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ShapeKit & in_shape_kit);
50114 
50115  HPS::PortfolioKey & portfolio_key;
50116  UTF8 name;
50117  HPS::ShapeKit & shape_kit;
50118  };
50119 
50120  class HPS_API GridImportEvent : public ImportEvent
50121  {
50123  GridImportEvent & operator=(GridImportEvent const &);
50124  public:
50125  GridImportEvent();
50126  virtual ~GridImportEvent();
50127  GridImportEvent(HPS::SegmentKey & in_segment_key, HPS::GridKit & in_grid_kit);
50128 
50129  HPS::SegmentKey & segment_key;
50130  HPS::GridKit & grid_kit;
50131  };
50132 
50134  {
50137  public:
50139  virtual ~HiddenLineAttributeImportEvent();
50140  HiddenLineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::HiddenLineAttributeKit & in_hidden_attribute_kit);
50141 
50142  HPS::SegmentKey & segment_key;
50143  HPS::HiddenLineAttributeKit & hidden_line_attribute_kit;
50144  };
50145 
50147  {
50150  public:
50152  virtual ~ImageDefinitionImportEvent();
50153  ImageDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ImageKit & in_image_kit);
50154 
50155  HPS::PortfolioKey & portfolio_key;
50156  UTF8 name;
50157  HPS::ImageKit & image_kit;
50158  };
50159 
50161  {
50164  public:
50166  virtual ~IncludeSegmentImportEvent();
50167  IncludeSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_reference_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
50168 
50169  HPS::SegmentKey & segment_key;
50170  HPS::SegmentKey & reference_segment_key;
50171  HPS::ConditionalExpression & condition;
50172  HPS::AttributeLockTypeArray filter_types;
50173  };
50174 
50175  class HPS_API InfiniteLineImportEvent : public ImportEvent
50176  {
50178  InfiniteLineImportEvent & operator=(InfiniteLineImportEvent const &);
50179  public:
50181  virtual ~InfiniteLineImportEvent();
50182  InfiniteLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::InfiniteLineKit & in_infinite_line_kit);
50183 
50184  HPS::SegmentKey & segment_key;
50185  HPS::InfiniteLineKit & infinite_line_kit;
50186  };
50187 
50189  {
50192  public:
50194  virtual ~LightingAttributeImportEvent();
50195  LightingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LightingAttributeKit & in_lighting_attribute_kit);
50196 
50197  HPS::SegmentKey & segment_key;
50198  HPS::LightingAttributeKit & lighting_attribute_kit;
50199  };
50200 
50201  class HPS_API LineAttributeImportEvent : public ImportEvent
50202  {
50205  public:
50207  virtual ~LineAttributeImportEvent();
50208  LineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineAttributeKit & in_line_attribute_kit);
50209 
50210  HPS::SegmentKey & segment_key;
50211  HPS::LineAttributeKit & line_attribute_kit;
50212  };
50213 
50214  class HPS_API LineImportEvent : public ImportEvent
50215  {
50217  LineImportEvent & operator=(LineImportEvent const &);
50218  public:
50219  LineImportEvent();
50220  virtual ~LineImportEvent();
50221  LineImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineKit & in_line_kit);
50222 
50223  HPS::SegmentKey & segment_key;
50224  HPS::LineKit & line_kit;
50225  };
50226 
50228  {
50231  public:
50234  LinePatternDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::LinePatternKit & in_line_pattern_kit);
50235 
50236  HPS::PortfolioKey & portfolio_key;
50237  UTF8 name;
50238  HPS::LinePatternKit & line_pattern_kit;
50239  };
50240 
50241  class HPS_API MarkerImportEvent : public ImportEvent
50242  {
50244  MarkerImportEvent & operator=(MarkerImportEvent const &);
50245  public:
50247  virtual ~MarkerImportEvent();
50248  MarkerImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerKit & in_marker_kit);
50249 
50250  HPS::SegmentKey & segment_key;
50251  HPS::MarkerKit & marker_kit;
50252  };
50253 
50255  {
50258  public:
50260  virtual ~MarkerAttributeImportEvent();
50261  MarkerAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerAttributeKit & in_marker_attribute_kit);
50262 
50263  HPS::SegmentKey & segment_key;
50264  HPS::MarkerAttributeKit & marker_attribute_kit;
50265  };
50266 
50267  class HPS_API MaterialImportEvent : public ImportEvent
50268  {
50270  MaterialImportEvent & operator=(MaterialImportEvent const &);
50271  public:
50273  virtual ~MaterialImportEvent();
50274  MaterialImportEvent(HPS::Key & in_key, HPS::MaterialMappingKit & in_material_mapping_kit);
50275 
50276  HPS::Key & key;
50277  HPS::MaterialMappingKit & material_mapping_kit;
50278  };
50279 
50281  {
50284  public:
50287  MaterialPaletteDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
50288 
50289  HPS::PortfolioKey & portfolio_key;
50290  HPS::UTF8 name;
50291  HPS::MaterialKitArray & material_mapping_kit_array;
50292  };
50293 
50295  {
50298  public:
50300  virtual ~MaterialPaletteImportEvent();
50301  MaterialPaletteImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name);
50302 
50303  HPS::SegmentKey & segment_key;
50304  HPS::UTF8 name;
50305  };
50306 
50307  class HPS_API MatrixImportEvent : public ImportEvent
50308  {
50310  MatrixImportEvent & operator=(MatrixImportEvent const &);
50311  public:
50313  virtual ~MatrixImportEvent();
50314  MatrixImportEvent(HPS::Key & in_key, HPS::MatrixKit & in_matrix_kit);
50315 
50316  HPS::Key & key;
50317  HPS::MatrixKit & matrix_kit;
50318  };
50319 
50320  class HPS_API MeshImportEvent : public ImportEvent
50321  {
50323  MeshImportEvent & operator=(MeshImportEvent const &);
50324  public:
50325  MeshImportEvent();
50326  virtual ~MeshImportEvent();
50327  MeshImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit);
50328 
50329  HPS::SegmentKey & segment_key;
50330  HPS::MeshKit & mesh_kit;
50331  };
50332 
50333  class HPS_API MeshInstanceImportEvent : public ImportEvent
50334  {
50336  MeshInstanceImportEvent & operator=(MeshInstanceImportEvent const &);
50337  public:
50339  virtual ~MeshInstanceImportEvent();
50340  MeshInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit, HPS::MatrixKit & in_modelling_matrix);
50341 
50342  HPS::SegmentKey & segment_key;
50343  HPS::MeshKit & mesh_kit;
50344  HPS::MatrixKit & modelling_matrix;
50345  };
50346 
50348  {
50351  public:
50354  NamedStyleDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::SegmentKey & in_style_key);
50355 
50356  HPS::PortfolioKey & portfolio_key;
50357  HPS::UTF8 name;
50358  HPS::SegmentKey & style_key;
50359  };
50360 
50361  class HPS_API NamedStyleImportEvent : public ImportEvent
50362  {
50364  NamedStyleImportEvent & operator=(NamedStyleImportEvent const &);
50365  public:
50367  virtual ~NamedStyleImportEvent();
50368  NamedStyleImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
50369 
50370  HPS::SegmentKey & segment_key;
50371  HPS::UTF8 name;
50372  HPS::ConditionalExpression & condition;
50373  HPS::AttributeLockTypeArray filter_types;
50374  };
50375 
50376  class HPS_API NURBSCurveImportEvent : public ImportEvent
50377  {
50379  NURBSCurveImportEvent & operator=(NURBSCurveImportEvent const &);
50380  public:
50382  virtual ~NURBSCurveImportEvent();
50383  NURBSCurveImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSCurveKit & in_nurbs_curve_kit);
50384 
50385  HPS::SegmentKey & segment_key;
50386  HPS::NURBSCurveKit & nurbs_curve_kit;
50387  };
50388 
50389  class HPS_API NURBSSurfaceImportEvent : public ImportEvent
50390  {
50392  NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent const &);
50393  public:
50395  virtual ~NURBSSurfaceImportEvent();
50396  NURBSSurfaceImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceKit & in_nurbs_surface_kit);
50397 
50398  HPS::SegmentKey & segment_key;
50399  HPS::NURBSSurfaceKit & nurbs_surface_kit;
50400  };
50401 
50403  {
50406  public:
50409  NURBSSurfaceAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceAttributeKit & in_nurbs_surface_attribute_kit);
50410 
50411  HPS::SegmentKey & segment_key;
50412  HPS::NURBSSurfaceAttributeKit & nurbs_surface_attribute_kit;
50413  };
50414 
50415  class HPS_API PerformanceImportEvent : public ImportEvent
50416  {
50418  PerformanceImportEvent & operator=(PerformanceImportEvent const &);
50419  public:
50421  virtual ~PerformanceImportEvent();
50422  PerformanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::PerformanceKit & in_performance_kit);
50423 
50424  HPS::SegmentKey & segment_key;
50425  HPS::PerformanceKit & performance_kit;
50426  };
50427 
50428  class HPS_API PolygonImportEvent : public ImportEvent
50429  {
50431  PolygonImportEvent & operator=(PolygonImportEvent const &);
50432  public:
50434  virtual ~PolygonImportEvent();
50435  PolygonImportEvent(HPS::SegmentKey & in_segment_key, HPS::PolygonKit & in_polygon_kit);
50436 
50437  HPS::SegmentKey & segment_key;
50438  HPS::PolygonKit & polygon_kit;
50439  };
50440 
50441  class HPS_API PriorityImportEvent : public ImportEvent
50442  {
50444  PriorityImportEvent & operator=(PriorityImportEvent const &);
50445  public:
50447  virtual ~PriorityImportEvent();
50448  PriorityImportEvent(HPS::Key & in_key, int in_priority);
50449 
50450  HPS::Key & key;
50451  int priority;
50452  };
50453 
50455  {
50458  public:
50460  virtual ~ReferenceGeometryImportEvent();
50461  ReferenceGeometryImportEvent(HPS::SegmentKey & in_segment_key, HPS::Key & in_reference_geometry_key, HPS::ConditionalExpression & in_conditional);
50462 
50463  HPS::SegmentKey & segment_key;
50464  HPS::Key & reference_geometry_key;
50465  HPS::ConditionalExpression & condition;
50466  };
50467 
50468  class HPS_API SegmentImportEvent : public ImportEvent
50469  {
50471  SegmentImportEvent & operator=(SegmentImportEvent const &);
50472  public:
50474  virtual ~SegmentImportEvent();
50475  SegmentImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name);
50476 
50477  HPS::SegmentKey & segment_key;
50478  HPS::UTF8 name;
50479  };
50480 
50481  class HPS_API SelectabilityImportEvent : public ImportEvent
50482  {
50485  public:
50487  virtual ~SelectabilityImportEvent();
50488  SelectabilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::SelectabilityKit & in_selectability_kit);
50489 
50490  HPS::SegmentKey & segment_key;
50491  HPS::SelectabilityKit & selectability_kit;
50492  };
50493 
50494  class HPS_API ShaderDefinitionImportEvent : public ImportEvent
50495  {
50496  ShaderDefinitionImportEvent(ShaderDefinitionImportEvent const &);
50497  ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent const &);
50498  public:
50499  ShaderDefinitionImportEvent();
50500  virtual ~ShaderDefinitionImportEvent();
50501  ShaderDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ShaderKit & in_shader_kit);
50502 
50503  HPS::PortfolioKey & portfolio_key;
50504  UTF8 name;
50505  HPS::ShaderKit & shader_kit;
50506  };
50507 
50508  class HPS_API ShellImportEvent : public ImportEvent
50509  {
50511  ShellImportEvent & operator=(ShellImportEvent const &);
50512  public:
50513  ShellImportEvent();
50514  virtual ~ShellImportEvent();
50515  ShellImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit);
50516 
50517  HPS::SegmentKey & segment_key;
50518  HPS::ShellKit & shell_kit;
50519  };
50520 
50521  class HPS_API ShellInstanceImportEvent : public ImportEvent
50522  {
50525  public:
50527  virtual ~ShellInstanceImportEvent();
50528  ShellInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit, HPS::MatrixKit & in_modelling_matrix);
50529 
50530  HPS::SegmentKey & segment_key;
50531  HPS::ShellKit & shell_kit;
50532  HPS::MatrixKit & modelling_matrix;
50533  };
50534 
50535  class HPS_API SphereImportEvent : public ImportEvent
50536  {
50538  SphereImportEvent & operator=(SphereImportEvent const &);
50539  public:
50541  virtual ~SphereImportEvent();
50542  SphereImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereKit & in_sphere_kit);
50543 
50544  HPS::SegmentKey & segment_key;
50545  HPS::SphereKit & sphere_kit;
50546  };
50547 
50549  {
50552  public:
50554  virtual ~SphereAttributeImportEvent();
50555  SphereAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereAttributeKit & in_sphere_attribute_kit);
50556 
50557  HPS::SegmentKey & segment_key;
50558  HPS::SphereAttributeKit & sphere_attribute_kit;
50559  };
50560 
50561  class HPS_API SpotlightImportEvent : public ImportEvent
50562  {
50564  SpotlightImportEvent & operator=(SpotlightImportEvent const &);
50565  public:
50567  virtual ~SpotlightImportEvent();
50568  SpotlightImportEvent(HPS::SegmentKey & in_segment_key, HPS::SpotlightKit & in_spotlight_kit);
50569 
50570  HPS::SegmentKey & segment_key;
50571  HPS::SpotlightKit & spotlight_kit;
50572  };
50573 
50574  class HPS_API StyleSegmentImportEvent : public ImportEvent
50575  {
50577  StyleSegmentImportEvent & operator=(StyleSegmentImportEvent const &);
50578  public:
50580  virtual ~StyleSegmentImportEvent();
50581  StyleSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_style_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
50582 
50583  HPS::SegmentKey & segment_key;
50584  HPS::SegmentKey & style_segment_key;
50585  HPS::ConditionalExpression & condition;
50586  HPS::AttributeLockTypeArray filter_types;
50587  };
50588 
50589  class HPS_API TextImportEvent : public ImportEvent
50590  {
50592  TextImportEvent & operator=(TextImportEvent const &);
50593  public:
50594  TextImportEvent();
50595  virtual ~TextImportEvent();
50596  TextImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextKit & in_text_kit);
50597 
50598  HPS::SegmentKey & segment_key;
50599  HPS::TextKit & text_kit;
50600  };
50601 
50602  class HPS_API TextAttributeImportEvent : public ImportEvent
50603  {
50606  public:
50608  virtual ~TextAttributeImportEvent();
50609  TextAttributeImportEvent(HPS::TextKey & in_text_key, HPS::TextAttributeKit & in_text_attribute_kit);
50610  TextAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextAttributeKit & in_text_attribute_kit);
50611 
50612  HPS::Key & key;
50613  HPS::TextAttributeKit & text_attribute_kit;
50614  };
50615 
50617  {
50620  public:
50622  virtual ~TextureDefinitionImportEvent();
50623  TextureDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name,
50624  HPS::ImageDefinition & in_source_definition, HPS::TextureOptionsKit & in_texture_kit);
50625 
50626  HPS::PortfolioKey & portfolio_key;
50627  UTF8 name;
50628  HPS::ImageDefinition & source_definition;
50629  HPS::TextureOptionsKit & texture_kit;
50630  };
50631 
50632  class HPS_API TransformMaskImportEvent : public ImportEvent
50633  {
50636  public:
50638  virtual ~TransformMaskImportEvent();
50639  TransformMaskImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransformMaskKit & in_transform_mask_kit);
50640 
50641  HPS::SegmentKey & segment_key;
50642  HPS::TransformMaskKit & transform_mask_kit;
50643  };
50644 
50645  class HPS_API TransparencyImportEvent : public ImportEvent
50646  {
50648  TransparencyImportEvent & operator=(TransparencyImportEvent const &);
50649  public:
50651  virtual ~TransparencyImportEvent();
50652  TransparencyImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransparencyKit & in_transparency_kit);
50653 
50654  HPS::SegmentKey & segment_key;
50655  HPS::TransparencyKit & transparency_kit;
50656  };
50657 
50658  class HPS_API SubwindowImportEvent : public ImportEvent
50659  {
50661  SubwindowImportEvent & operator=(SubwindowImportEvent const &);
50662  public:
50664  virtual ~SubwindowImportEvent();
50665  SubwindowImportEvent(HPS::SegmentKey & in_segment_key, HPS::SubwindowKit & in_subwindow_kit);
50666 
50667  HPS::SegmentKey & segment_key;
50668  HPS::SubwindowKit & subwindow_kit;
50669  };
50670 
50672  class HPS_API NonDBUserDataImportEvent : public ImportEvent
50673  {
50676  public:
50678  virtual ~NonDBUserDataImportEvent();
50679  NonDBUserDataImportEvent(size_t in_count, HPS::byte const in_data[]);
50680 
50683  };
50684 
50686  class HPS_API UserDataImportEvent : public ImportEvent
50687  {
50689  UserDataImportEvent & operator=(UserDataImportEvent const &);
50690  public:
50691  virtual ~UserDataImportEvent();
50693  UserDataImportEvent(HPS::Key & in_key, intptr_t in_index, size_t in_count, HPS::byte const in_data[]);
50694 
50695  HPS::Key key;
50696  intptr_t index;
50697 
50700  };
50701 
50702  class HPS_API VisibilityImportEvent : public ImportEvent
50703  {
50705  VisibilityImportEvent & operator=(VisibilityImportEvent const &);
50706  public:
50708  virtual ~VisibilityImportEvent();
50709  VisibilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisibilityKit & in_visibility_kit);
50710 
50711  HPS::SegmentKey & segment_key;
50712  HPS::VisibilityKit & visibility_kit;
50713  };
50714 
50715  class HPS_API VisualEffectsImportEvent : public ImportEvent
50716  {
50719  public:
50721  virtual ~VisualEffectsImportEvent();
50722  VisualEffectsImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisualEffectsKit & in_visual_effects_kit);
50723 
50724  HPS::SegmentKey & segment_key;
50725  HPS::VisualEffectsKit & visual_effects_kit;
50726  };
50727 
50729 
50730 
50732  class HPS_API ImportOptionsKit : public Kit
50733  {
50734  public:
50736  ImportOptionsKit();
50737 
50740  ImportOptionsKit(ImportOptionsKit const & in_kit);
50741 
50745  ImportOptionsKit(ImportOptionsKit && in_that);
50746 
50750  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
50751 
50752  virtual ~ImportOptionsKit();
50753 
50754  static const HPS::Type staticType = HPS::Type::StreamImportOptionsKit;
50755  HPS::Type ObjectType() const { return staticType; };
50756 
50759  void Set(ImportOptionsKit const & in_kit);
50760 
50763  void Show(ImportOptionsKit & out_kit) const;
50764 
50768  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
50769 
50772  bool Empty() const;
50773 
50777  bool Equals(ImportOptionsKit const & in_kit) const;
50778 
50782  bool operator==(ImportOptionsKit const & in_kit) const;
50783 
50787  bool operator!=(ImportOptionsKit const & in_kit) const;
50788 
50791  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
50792 
50795  ImportOptionsKit & UnsetToolkit();
50796 
50800  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
50801 
50806  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
50807 
50810  ImportOptionsKit & UnsetSegment();
50811 
50815  bool ShowSegment(SegmentKey & out_segment) const;
50816 
50821  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
50822 
50825  ImportOptionsKit & UnsetAlternateRoot();
50826 
50830  bool ShowAlternateRoot(SegmentKey & out_segment) const;
50831 
50836  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
50837 
50840  ImportOptionsKit & UnsetPortfolio();
50841 
50845  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
50846 
50849  ImportOptionsKit & UnsetEverything();
50850 
50855  ImportOptionsKit & SetEventHandler(HPS::Stream::ImportEventHandler & in_handler, intptr_t in_type);
50856 
50860  ImportOptionsKit & UnsetEventHandler(intptr_t in_type);
50861 
50864  ImportOptionsKit & UnsetEventHandlers();
50865  };
50866 
50868  class HPS_API ImportResultsKit : public Kit
50869  {
50870  public:
50872  ImportResultsKit();
50873 
50876  ImportResultsKit(ImportResultsKit const & in_kit);
50877 
50881  ImportResultsKit(ImportResultsKit && in_that);
50882 
50886  ImportResultsKit & operator=(ImportResultsKit && in_that);
50887 
50888  virtual ~ImportResultsKit();
50889 
50890  static const HPS::Type staticType = HPS::Type::StreamImportResultsKit;
50891  HPS::Type ObjectType() const { return staticType; };
50892 
50895  void Set(ImportResultsKit const & in_kit);
50896 
50899  void Show(ImportResultsKit & out_kit) const;
50900 
50904  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
50905 
50908  bool Empty() const;
50909 
50913  bool Equals(ImportResultsKit const & in_kit) const;
50914 
50918  bool operator==(ImportResultsKit const & in_kit) const;
50919 
50923  bool operator!=(ImportResultsKit const & in_kit) const;
50924 
50929  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
50930 
50934  ImportResultsKit & UnsetSegment();
50935 
50940  bool ShowSegment(SegmentKey & out_segment) const;
50941 
50946  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
50947 
50951  ImportResultsKit & UnsetAlternateRoot();
50952 
50958  bool ShowAlternateRoot(SegmentKey & out_segment) const;
50959 
50964  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
50965 
50969  ImportResultsKit & UnsetPortfolio();
50970 
50976  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
50977 
50982  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
50983 
50987  ImportResultsKit & UnsetDefaultCamera();
50988 
50993  bool ShowDefaultCamera(CameraKit & out_camera) const;
50994 
50995 
51001  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
51002 
51006  ImportResultsKit & UnsetAlternateCameras();
51007 
51012  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
51013 
51014 
51017  ImportResultsKit & UnsetEverything();
51018  };
51019 
51021  class HPS_API ExportOptionsKit : public Kit
51022  {
51023  public:
51025  ExportOptionsKit();
51026 
51029  ExportOptionsKit(ExportOptionsKit const & in_kit);
51030 
51034  ExportOptionsKit(ExportOptionsKit && in_that);
51035 
51039  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
51040 
51044  static ExportOptionsKit GetDefault();
51045 
51046  virtual ~ExportOptionsKit();
51047 
51048  static const HPS::Type staticType = HPS::Type::StreamExportOptionsKit;
51049  HPS::Type ObjectType() const { return staticType; };
51050 
51053  void Set(ExportOptionsKit const & in_kit);
51054 
51057  void Show(ExportOptionsKit & out_kit) const;
51058 
51062  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
51063 
51066  bool Empty() const;
51067 
51071  bool Equals(ExportOptionsKit const & in_kit) const;
51072 
51076  bool operator==(ExportOptionsKit const & in_kit) const;
51077 
51081  bool operator!=(ExportOptionsKit const & in_kit) const;
51082 
51085  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
51086 
51090  ExportOptionsKit & SetDefaultCamera(CameraKit const & in_camera);
51091 
51099  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
51100 
51108  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
51109 
51115  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
51116 
51124  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
51125 
51133  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
51134 
51140  ExportOptionsKit & SetConnectivityCompression(bool in_state);
51141 
51147  ExportOptionsKit & SetSerializeTristrips(bool in_state);
51148 
51157  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
51158 
51161  ExportOptionsKit & UnsetToolkit();
51162 
51165  ExportOptionsKit & UnsetDefaultCamera();
51166 
51169  ExportOptionsKit & UnsetVertexCompression();
51170 
51173  ExportOptionsKit & UnsetNormalCompression();
51174 
51177  ExportOptionsKit & UnsetParameterCompression();
51178 
51181  ExportOptionsKit & UnsetColorCompression();
51182 
51185  ExportOptionsKit & UnsetIndexCompression();
51186 
51189  ExportOptionsKit & UnsetConnectivityCompression();
51190 
51193  ExportOptionsKit & UnsetImageCompression();
51194 
51197  ExportOptionsKit & UnsetSerializeTristrips();
51198 
51201  ExportOptionsKit & UnsetEverything();
51202 
51206  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
51207 
51211  bool ShowDefaultCamera(CameraKit & out_camera) const;
51212 
51217  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
51218 
51223  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
51224 
51229  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
51230 
51235  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
51236 
51241  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
51242 
51246  bool ShowConnectivityCompression(bool & out_state) const;
51247 
51252  bool ShowImageCompression(bool & out_state, float & out_quality) const;
51253 
51257  bool ShowSerializeTristrips(bool & out_state) const;
51258 
51263  ExportOptionsKit & SetEventHandler(HPS::Stream::ExportEventHandler & in_handler, intptr_t in_type);
51264 
51268  ExportOptionsKit & UnsetEventHandler(intptr_t in_type);
51269 
51272  ExportOptionsKit & UnsetEventHandlers();
51273  };
51274 
51277  class HPS_API ImportNotifier : public IONotifier
51278  {
51279  public:
51281  ImportNotifier();
51282 
51285  ImportNotifier(ImportNotifier const & in_that);
51286 
51291  ImportNotifier(IONotifier const & in_that);
51292 
51296  ImportNotifier(ImportNotifier && in_that);
51297 
51301  ImportNotifier & operator=(ImportNotifier && in_that);
51302 
51303  virtual ~ImportNotifier();
51304 
51305  static const HPS::Type staticType = HPS::Type::StreamImportNotifier;
51306  HPS::Type ObjectType() const {return staticType;};
51307 
51311  ImportNotifier & operator=(ImportNotifier const & in_that);
51312 
51315  void Assign(ImportNotifier const & in_that);
51316 
51320  ImportResultsKit GetResults() const;
51321  };
51322 
51325  class HPS_API ExportNotifier : public IONotifier
51326  {
51327  public:
51329  ExportNotifier();
51330 
51333  ExportNotifier(ExportNotifier const & in_that);
51334 
51339  ExportNotifier(IONotifier const & in_that);
51340 
51344  ExportNotifier(ExportNotifier && in_that);
51345 
51349  ExportNotifier & operator=(ExportNotifier && in_that);
51350 
51351  virtual ~ExportNotifier();
51352 
51353  static const HPS::Type staticType = HPS::Type::StreamExportNotifier;
51354  HPS::Type ObjectType() const {return staticType;};
51355 
51359  ExportNotifier & operator=(ExportNotifier const & in_that);
51360 
51363  void Assign(ExportNotifier const & in_that);
51364  };
51365 
51366 
51368  class HPS_API File
51369  {
51370  public:
51376  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
51377 
51383  static ImportNotifier Import(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
51384 
51391  static ExportNotifier Export(char const * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
51392 
51399  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
51400 
51401  private:
51403  File();
51404  };
51405 private:
51407  Stream();
51408 };
51409 
51413 
51418 class HPS_API Hardcopy
51419 {
51420 public:
51421 
51423  enum class SizeUnits : uint32_t
51424  {
51425  Centimeters,
51426  Inches,
51427  };
51428 
51430  enum class ResolutionUnits : uint32_t
51431  {
51432  DPCM,
51433  DPI,
51434  DotsPerCentimeter = DPCM,
51435  DotsPerInch = DPI,
51436  };
51437 
51439  enum class BackgroundPreference : uint32_t
51440  {
51441  UseBackgroundColor,
51442  ForceSolidWhite,
51443  };
51444 
51446  enum class RenderingAlgorithm : uint32_t
51447  {
51448  TwoPassPrint,
51449  SinglePassPrint,
51450  };
51451 
51453  enum class PDFFontPreference : uint32_t
51454  {
51455  DoNotEmbedFonts,
51456  EmbedFonts,
51457  };
51458 
51460  class HPS_API File
51461  {
51462  public:
51463 
51465  class HPS_API ExportOptionsKit : public Kit
51466  {
51467  public:
51469  ExportOptionsKit();
51470 
51473  ExportOptionsKit(ExportOptionsKit const & in_kit);
51474 
51478  ExportOptionsKit(ExportOptionsKit && in_that);
51479 
51483  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
51484 
51485  virtual ~ExportOptionsKit();
51486 
51487  static const HPS::Type staticType = HPS::Type::HardcopyExportOptionsKit;
51488  HPS::Type ObjectType() const { return staticType; };
51489 
51492  void Set(ExportOptionsKit const & in_kit);
51493 
51496  void Show(ExportOptionsKit & out_kit) const;
51497 
51501  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
51502 
51505  bool Empty() const;
51506 
51510  bool Equals(ExportOptionsKit const & in_kit) const;
51511 
51515  bool operator==(ExportOptionsKit const & in_kit) const;
51516 
51520  bool operator!=(ExportOptionsKit const & in_kit) const;
51521 
51522 
51523 
51524 
51530  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
51531 
51539  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
51540 
51543  ExportOptionsKit & UnsetSize();
51544 
51545 
51546 
51552  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
51553 
51560  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
51561 
51564  ExportOptionsKit & UnsetResolution();
51565 
51571  bool ShowHiddenLineSorting(bool & out_state, float & out_threshold, HPS::Line::SizeUnits & out_units) const;
51572 
51582  ExportOptionsKit & SetHiddenLineSorting(bool in_on, float in_activation_weight = 2.0f, HPS::Line::SizeUnits in_units = HPS::Line::SizeUnits::Pixels);
51583 
51586  ExportOptionsKit & UnsetHiddenLineSorting();
51587 
51588 
51592  bool ShowWYSIWYG(bool & out_onoff) const;
51593 
51605  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
51606 
51609  ExportOptionsKit & UnsetWYSIWYG();
51610 
51615  bool ShowScale(float & out_scale, HPS::Hardcopy::SizeUnits & out_units) const;
51616 
51626  ExportOptionsKit & SetScale(float in_scale, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
51627 
51630  ExportOptionsKit & UnsetScale();
51631 
51635  bool ShowBackgroundPreference(Hardcopy::BackgroundPreference & out_background_preference) const;
51636 
51641  ExportOptionsKit & SetBackgroundPreference(Hardcopy::BackgroundPreference in_background_preference);
51642 
51645  ExportOptionsKit & UnsetBackgroundPreference();
51646 
51647 
51651  bool ShowRenderingAlgorithm(Hardcopy::RenderingAlgorithm & out_rendering_algorithm) const;
51652 
51657  ExportOptionsKit & SetRenderingAlgorithm(Hardcopy::RenderingAlgorithm in_rendering_algorithm);
51658 
51661  ExportOptionsKit & UnsetRenderingAlgorithm();
51662 
51666  bool ShowPDFFontPreference(Hardcopy::PDFFontPreference & out_pdf_font_preference) const;
51667 
51676  ExportOptionsKit & SetPDFFontPreference(Hardcopy::PDFFontPreference in_pdf_font_preference);
51677 
51680  ExportOptionsKit & UnsetPDFFontPreference();
51681 
51682 
51685  ExportOptionsKit & UnsetEverything();
51686 
51687 
51691  static ExportOptionsKit GetDefault();
51692  };
51693 
51695  enum class Driver : uint32_t
51696  {
51697  PDF,
51698  Postscript
51699  };
51700 
51706  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
51707  private:
51708  File();
51709  };
51710 
51711 #ifdef _MSC_VER
51712  class HPS_API GDI
51713  {
51714  public:
51715 
51717  class HPS_API ExportOptionsKit : public Kit
51718  {
51719  public:
51721  ExportOptionsKit();
51722 
51725  ExportOptionsKit(ExportOptionsKit const & in_kit);
51726 
51730  ExportOptionsKit(ExportOptionsKit && in_that);
51731 
51735  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
51736 
51737  virtual ~ExportOptionsKit();
51738 
51739  static const HPS::Type staticType = HPS::Type::HardcopyGDIExportOptionsKit;
51740  HPS::Type ObjectType() const { return staticType; };
51741 
51744  void Set(ExportOptionsKit const & in_kit);
51745 
51748  void Show(ExportOptionsKit & out_kit) const;
51749 
51753  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
51754 
51757  bool Empty() const;
51758 
51762  bool Equals(ExportOptionsKit const & in_kit) const;
51763 
51767  bool operator==(ExportOptionsKit const & in_kit) const;
51768 
51772  bool operator!=(ExportOptionsKit const & in_kit) const;
51773 
51774 
51779  bool ShowSize(float & out_width, float & out_height) const;
51780 
51785  ExportOptionsKit & SetSize(float in_width, float in_height);
51786 
51789  ExportOptionsKit & UnsetSize();
51790 
51791 
51795  bool ShowResolution(float & out_resolution) const;
51796 
51800  ExportOptionsKit & SetResolution(float in_resolution);
51801 
51804  ExportOptionsKit & UnsetResolution();
51805 
51811  bool ShowHiddenLineSorting(bool & out_state, float & out_threshold, HPS::Line::SizeUnits & out_units) const;
51812 
51822  ExportOptionsKit & SetHiddenLineSorting(bool in_on, float in_activation_weight = 2.0f, HPS::Line::SizeUnits in_units = HPS::Line::SizeUnits::Pixels);
51823 
51826  ExportOptionsKit & UnsetHiddenLineSorting();
51827 
51830  bool ShowWYSIWYG(bool & out_onoff) const;
51831 
51835  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
51836 
51839  ExportOptionsKit & UnsetWYSIWYG();
51840 
51845  bool ShowScale(float & out_scale, HPS::Hardcopy::SizeUnits & out_units) const;
51846 
51856  ExportOptionsKit & SetScale(float in_scale, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
51857 
51860  ExportOptionsKit & UnsetScale();
51861 
51865  bool ShowBackgroundPreference(Hardcopy::BackgroundPreference & out_background_preference) const;
51866 
51871  ExportOptionsKit & SetBackgroundPreference(Hardcopy::BackgroundPreference in_background_preference);
51872 
51875  ExportOptionsKit & UnsetBackgroundPreference();
51876 
51877 
51881  bool ShowRenderingAlgorithm(Hardcopy::RenderingAlgorithm & out_rendering_algorithm) const;
51882 
51887  ExportOptionsKit & SetRenderingAlgorithm(Hardcopy::RenderingAlgorithm in_rendering_algorithm);
51888 
51891  ExportOptionsKit & UnsetRenderingAlgorithm();
51892 
51893 
51896  ExportOptionsKit & UnsetEverything();
51897  };
51898 
51905  static IOResult Export(intptr_t in_hdc, intptr_t in_attribdc, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
51906 
51911  static IOResult ExportClipboard(HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
51912 
51918  static IOResult ExportEMF(char const * in_filename, WindowKey const & in_window, ExportOptionsKit const & in_options);
51919 
51920  private:
51921  GDI();
51922  };
51923 #endif
51924 
51925 private:
51926  Hardcopy();
51927 };
51928 
51932 
51934 class HPS_API OBJ
51935 {
51936 public:
51937 
51939  class HPS_API ImportOptionsKit : public Kit
51940  {
51941  public:
51943  ImportOptionsKit();
51944 
51947  ImportOptionsKit(ImportOptionsKit const & in_kit);
51948 
51952  ImportOptionsKit(ImportOptionsKit && in_that);
51953 
51957  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
51958 
51959  virtual ~ImportOptionsKit();
51960 
51961  static const HPS::Type staticType = HPS::Type::OBJImportOptionsKit;
51962  HPS::Type ObjectType() const { return staticType; };
51963 
51966  void Set(ImportOptionsKit const & in_kit);
51967 
51970  void Show(ImportOptionsKit & out_kit) const;
51971 
51975  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
51976 
51979  bool Empty() const;
51980 
51984  bool Equals(ImportOptionsKit const & in_kit) const;
51985 
51989  bool operator==(ImportOptionsKit const & in_kit) const;
51990 
51994  bool operator!=(ImportOptionsKit const & in_kit) const;
51995 
52000  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
52001 
52004  ImportOptionsKit & UnsetSegment();
52005 
52009  bool ShowSegment(SegmentKey & out_segment) const;
52010 
52015  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
52016 
52019  ImportOptionsKit & UnsetPortfolio();
52020 
52024  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
52025 
52031  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
52032 
52035  ImportOptionsKit & UnsetHandedness();
52036 
52040  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
52041 
52044  ImportOptionsKit & UnsetEverything();
52045  };
52046 
52048  class HPS_API ImportResultsKit : public Kit
52049  {
52050  public:
52052  ImportResultsKit();
52053 
52056  ImportResultsKit(ImportResultsKit const & in_kit);
52057 
52061  ImportResultsKit(ImportResultsKit && in_that);
52062 
52066  ImportResultsKit & operator=(ImportResultsKit && in_that);
52067 
52068  virtual ~ImportResultsKit();
52069 
52070  static const HPS::Type staticType = HPS::Type::OBJImportResultsKit;
52071  HPS::Type ObjectType() const { return staticType; };
52072 
52075  void Set(ImportResultsKit const & in_kit);
52076 
52079  void Show(ImportResultsKit & out_kit) const;
52080 
52084  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
52085 
52088  bool Empty() const;
52089 
52093  bool Equals(ImportResultsKit const & in_kit) const;
52094 
52098  bool operator==(ImportResultsKit const & in_kit) const;
52099 
52103  bool operator!=(ImportResultsKit const & in_kit) const;
52104 
52109  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
52110 
52114  ImportResultsKit & UnsetSegment();
52115 
52120  bool ShowSegment(SegmentKey & out_segment) const;
52121 
52126  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
52127 
52131  ImportResultsKit & UnsetPortfolio();
52132 
52138  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
52139 
52144  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
52145 
52149  ImportResultsKit & UnsetHandedness();
52150 
52155  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
52156 
52159  ImportResultsKit & UnsetEverything();
52160  };
52161 
52164  class HPS_API ImportNotifier : public IONotifier
52165  {
52166  public:
52168  ImportNotifier();
52169 
52172  ImportNotifier(ImportNotifier const & in_that);
52173 
52178  ImportNotifier(IONotifier const & in_that);
52179 
52183  ImportNotifier(ImportNotifier && in_that);
52184 
52188  ImportNotifier & operator=(ImportNotifier && in_that);
52189 
52190  virtual ~ImportNotifier();
52191 
52192  static const HPS::Type staticType = HPS::Type::OBJImportNotifier;
52193  HPS::Type ObjectType() const {return staticType;};
52194 
52198  ImportNotifier & operator=(ImportNotifier const & in_that);
52199 
52202  void Assign(ImportNotifier const & in_that);
52203 
52207  ImportResultsKit GetResults() const;
52208  };
52209 
52212  class HPS_API ExportNotifier : public IONotifier
52213  {
52214  public:
52216  ExportNotifier();
52217 
52220  ExportNotifier(ExportNotifier const & in_that);
52221 
52226  ExportNotifier(IONotifier const & in_that);
52227 
52231  ExportNotifier(ExportNotifier && in_that);
52232 
52236  ExportNotifier & operator=(ExportNotifier && in_that);
52237 
52238  virtual ~ExportNotifier();
52239 
52240  static const HPS::Type staticType = HPS::Type::OBJExportNotifier;
52241  HPS::Type ObjectType() const { return staticType; };
52242 
52246  ExportNotifier & operator=(ExportNotifier const & in_that);
52247 
52250  void Assign(ExportNotifier const & in_that);
52251  };
52252 
52253 
52255  class HPS_API File
52256  {
52257  public:
52263  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
52264 
52271  static ExportNotifier Export(char const * in_file_name, HPS::KeyPath const & in_key_path_to_export);
52272 
52273  private:
52275  File();
52276  };
52277 private:
52279  OBJ();
52280 };
52281 
52285 
52287 class HPS_API STL
52288 {
52289 public:
52290 
52292  class HPS_API ImportOptionsKit : public Kit
52293  {
52294  public:
52296  ImportOptionsKit();
52297 
52300  ImportOptionsKit(ImportOptionsKit const & in_kit);
52301 
52305  ImportOptionsKit(ImportOptionsKit && in_that);
52306 
52310  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
52311 
52312  virtual ~ImportOptionsKit();
52313 
52314  static const HPS::Type staticType = HPS::Type::STLImportOptionsKit;
52315  HPS::Type ObjectType() const { return staticType; };
52316 
52319  void Set(ImportOptionsKit const & in_kit);
52320 
52323  void Show(ImportOptionsKit & out_kit) const;
52324 
52328  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
52329 
52332  bool Empty() const;
52333 
52337  bool Equals(ImportOptionsKit const & in_kit) const;
52338 
52342  bool operator==(ImportOptionsKit const & in_kit) const;
52343 
52347  bool operator!=(ImportOptionsKit const & in_kit) const;
52348 
52352  static ImportOptionsKit GetDefault();
52353 
52358  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
52359 
52367  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
52368 
52375  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
52376 
52377 
52380  ImportOptionsKit & UnsetSegment();
52381 
52384  ImportOptionsKit & UnsetOptimization();
52385 
52388  ImportOptionsKit & UnsetEverything();
52389 
52390 
52394  bool ShowSegment(SegmentKey & out_segment) const;
52395 
52400  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
52401  };
52402 
52404  class HPS_API ImportResultsKit : public Kit
52405  {
52406  public:
52408  ImportResultsKit();
52409 
52412  ImportResultsKit(ImportResultsKit const & in_kit);
52413 
52417  ImportResultsKit(ImportResultsKit && in_that);
52418 
52422  ImportResultsKit & operator=(ImportResultsKit && in_that);
52423 
52424  virtual ~ImportResultsKit();
52425 
52426  static const HPS::Type staticType = HPS::Type::STLImportResultsKit;
52427  HPS::Type ObjectType() const { return staticType; };
52428 
52431  void Set(ImportResultsKit const & in_kit);
52432 
52435  void Show(ImportResultsKit & out_kit) const;
52436 
52440  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
52441 
52444  bool Empty() const;
52445 
52449  bool Equals(ImportResultsKit const & in_kit) const;
52450 
52454  bool operator==(ImportResultsKit const & in_kit) const;
52455 
52459  bool operator!=(ImportResultsKit const & in_kit) const;
52460 
52465  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
52466 
52470  ImportResultsKit & UnsetSegment();
52471 
52476  bool ShowSegment(SegmentKey & out_segment) const;
52477 
52480  ImportResultsKit & UnsetEverything();
52481  };
52482 
52485  class HPS_API ImportNotifier : public IONotifier
52486  {
52487  public:
52489  ImportNotifier();
52490 
52493  ImportNotifier(ImportNotifier const & in_that);
52494 
52499  ImportNotifier(IONotifier const & in_that);
52500 
52504  ImportNotifier(ImportNotifier && in_that);
52505 
52509  ImportNotifier & operator=(ImportNotifier && in_that);
52510 
52511  virtual ~ImportNotifier();
52512 
52513  static const HPS::Type staticType = HPS::Type::STLImportNotifier;
52514  HPS::Type ObjectType() const {return staticType;};
52515 
52519  ImportNotifier & operator=(ImportNotifier const & in_that);
52520 
52523  void Assign(ImportNotifier const & in_that);
52524 
52528  ImportResultsKit GetResults() const;
52529  };
52530 
52531 
52533  class HPS_API File
52534  {
52535  public:
52541  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
52542 
52543  private:
52545  File();
52546  };
52547 private:
52549  STL();
52550 };
52551 
52552 }
52553 
52554 #ifdef _MSC_VER
52555 # pragma warning(pop)
52556 #endif
52557 
52558 #endif
52559 
52560 
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:47742
CameraPoint(Point const &in_point)
Definition: hps.h:6301
HPS::Type ObjectType() const
Definition: hps.h:18853
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:48770
Definition: hps.h:3488
Definition: hps.h:6418
Definition: hps.h:85
StaticConditions
Definition: hps.h:1148
Material Texture ChannelMapping.
std::vector< WindowKey, Allocator< WindowKey > > WindowKeyArray
Array of type HPS::WindowKey.
Definition: hps.h:6847
Definition: hps.h:15863
Definition: hps.h:1071
HPS::Type ObjectType() const
Definition: hps.h:13987
HPS::Type ObjectType() const
Definition: hps.h:52427
Definition: hps.h:13230
bool operator==(ShapePoint const &in_that) const
Definition: hps.h:7025
Event(intptr_t in_channel=0)
Definition: hps.h:6516
Definition: hps.h:20387
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3995
HPS::ByteArray user_data
Definition: hps.h:50682
void ScrollLock(bool in_state)
Definition: hps.h:48126
float alpha
Definition: hps.h:4613
HPS::Type ObjectType() const
Definition: hps.h:32007
HPS::Type ObjectType() const
Definition: hps.h:38398
Definition: hps.h:39210
HPS::Type ObjectType() const
Definition: hps.h:51354
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:48713
std::vector< Search::Type, Allocator< Search::Type > > SearchTypeArray
Array of type HPS::Search::Type.
Definition: hps.h:6867
HPS::Type ObjectType() const
Definition: hps.h:47222
void X1(bool in_state)
Definition: hps.h:48567
Search for all attributes, geometry, segments, includes and includers.
Event * Clone() const
Definition: hps.h:47986
HPS::Type ObjectType() const
Definition: hps.h:33807
void RightMeta(bool in_state)
Definition: hps.h:48154
size_t statics_created_count
Number of static models that were created during the last update.
Definition: hps.h:5204
void Shift(bool in_state)
Definition: hps.h:48102
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:47686
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:5191
Definition: hps.h:9303
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:5200
Definition: hps.h:49808
HPS::Type ObjectType() const
Definition: hps.h:21556
Definition: hps.h:23380
Definition: sprk_exchange.h:44
Definition: hps.h:46527
HPS::Type ObjectType() const
Definition: hps.h:40052
void CapsLock(bool in_state)
Definition: hps.h:48118
HPS::Type ObjectType() const
Definition: hps.h:52241
Definition: hps.h:50066
virtual HPS::Type Type() const
Definition: hps.h:21004
Definition: hps.h:14768
Orientation
Definition: hps.h:538
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:48677
virtual HPS::Type Type() const
Definition: hps.h:46267
Definition: hps.h:51934
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:47372
ImportStatusEvent()
Definition: hps.h:47901
HPS::Type ObjectType() const
Definition: hps.h:13909
HPS::Type ObjectType() const
Definition: hps.h:27475
Parameterization
Definition: hps.h:965
HPS::Type ObjectType() const
Definition: hps.h:38805
std::vector< LinePatternDefinition, Allocator< LinePatternDefinition > > LinePatternDefinitionArray
Array of type HPS::LinePatternDefinition.
Definition: hps.h:6877
Definition: hps.h:15378
size_t text_3d_count
Number of 3D text drawn during the last update.
Definition: hps.h:5186
Definition: hps.h:49631
HPS::Type ObjectType() const
Definition: hps.h:39738
virtual HPS::Type Type() const
Definition: hps.h:6183
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:5199
LeaderLineSpace
Definition: hps.h:1743
std::vector< ShaderDefinition, Allocator< ShaderDefinition > > ShaderDefinitionArray
Array of type HPS::ShaderDefinition.
Definition: hps.h:6878
static MouseButtons ButtonX2()
Definition: hps.h:48622
Definition: hps.h:22228
Definition: hps.h:17559
HPS::Type ObjectType() const
Definition: hps.h:41295
Type
Definition: hps.h:265
Fill
Definition: hps.h:2060
Event * Clone() const
Definition: hps.h:47780
Search the current segment only.
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:48886
Definition: hps.h:52404
HPS::Type ObjectType() const
Definition: hps.h:51962
Definition: hps.h:43571
Definition: hps.h:21530
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6214
Definition: hps.h:50376
Transform
Definition: hps.h:1628
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6340
Behavior
Definition: hps.h:589
DisplayLists
Definition: hps.h:1114
Definition: hps.h:473
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2431
Event * Clone() const
Definition: hps.h:47584
bool operator!=(ShapeCoordinate const &in_that) const
Definition: hps.h:6971
Modifier
Definition: hps.h:1996
Definition: hps.h:40161
HPS::Type ObjectType() const
Definition: hps.h:11931
Definition: hps.h:48778
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:9319
std::vector< LinePatternElement, Allocator< LinePatternElement > > LinePatternElementArray
Array of type HPS::LinePatternElement.
Definition: hps.h:6864
virtual HPS::Type Type() const
Definition: hps.h:18754
Definition: hps.h:10255
HPS::Type ObjectType() const
Definition: hps.h:19594
Overlay
Definition: hps.h:1330
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:5178
virtual HPS::Type Type() const
Definition: hps.h:22633
Definition: hps.h:50320
std::vector< SegmentKey, Allocator< SegmentKey > > SegmentKeyArray
Array of type HPS::SegmentKey.
Definition: hps.h:6846
static ModifierKeys KeyLeftMeta()
Definition: hps.h:48253
Definition: hps.h:29630
HPS::Type ObjectType() const
Definition: hps.h:15492
HPS::Type ObjectType() const
Definition: hps.h:10825
InputEvent()
Definition: hps.h:48290
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:4107
HPS::Type ObjectType() const
Definition: hps.h:40474
virtual HPS::Type Type() const
Definition: hps.h:12328
HPS::Type ObjectType() const
Definition: hps.h:44084
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:6022
HPS::UTF8 text
The text for this TextInputEvent.
Definition: hps.h:47849
Event * Clone() const
Definition: hps.h:47401
ClipSpace
Definition: hps.h:1360
Definition: hps.h:41313
Definition: hps.h:40127
static MouseButtons ButtonRight()
Definition: hps.h:48610
std::vector< CameraKit, Allocator< CameraKit > > CameraKitArray
Array of type HPS::CameraKit.
Definition: hps.h:6869
HPS::Type ObjectType() const
Definition: hps.h:28471
Definition: hps.h:2288
Event * Clone() const
Definition: hps.h:47733
bool RightMeta() const
Definition: hps.h:48083
bool None() const
Definition: hps.h:48027
HPS::Type ObjectType() const
Definition: hps.h:29879
Definition: hps.h:6062
RenderingAlgorithm
Definition: hps.h:282
HPS::Type ObjectType() const
Definition: hps.h:29950
Definition: hps.h:40451
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:48815
static ModifierKeys KeyMeta()
Definition: hps.h:48209
Definition: hps.h:1572
Definition: hps.h:26615
bool Shift() const
Definition: hps.h:48031
The clip region is specified in world coordinated.
HPS::Type ObjectType() const
Definition: hps.h:11677
Definition: hps.h:18732
std::vector< Vector, Allocator< Vector > > VectorArray
Array of type HPS::Vector.
Definition: hps.h:6837
std::vector< PixelPoint, Allocator< PixelPoint > > PixelPointArray
Array of type HPS::PixelPoint.
Definition: hps.h:6836
Definition: hps.h:6998
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3981
Definition: hps.h:39658
std::vector< Drawing::Overlay, Allocator< Drawing::Overlay > > DrawingOverlayArray
Array of type HPS::Drawing::Overlay.
Definition: hps.h:6902
HPS::Type ObjectType() const
Definition: hps.h:40156
Decimation
Definition: hps.h:1031
HPS::Type ObjectType() const
Definition: hps.h:52315
Definition: hps.h:49285
Definition: hps.h:43956
Definition: hps.h:25351
MouseButtons()
Definition: hps.h:48492
HPS::Type ObjectType() const
Definition: hps.h:37769
Definition: hps.h:22981
Definition: hps.h:52533
void Left(bool in_state)
Definition: hps.h:48555
HPS::Type ObjectType() const
Definition: hps.h:7277
HPS::Type ObjectType() const
Definition: hps.h:29153
std::vector< EventHandler, Allocator< EventHandler > > EventHandlerArray
Array of type HPS::EventHandler.
Definition: hps.h:6848
std::vector< LineKey, Allocator< LineKey > > LineKeyArray
Array of type HPS::LineKey.
Definition: hps.h:6907
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:4047
bool Control() const
Definition: hps.h:48035
Definition: hps.h:49873
Kit(Kit &&in_that)
Definition: hps.h:6195
Definition: hps.h:41182
The vertex colors applied to faces.
OuterConeUnits
Definition: hps.h:479
Definition: hps.h:46874
KeyboardEvent()
Definition: hps.h:48791
HPS::Type ObjectType() const
Definition: hps.h:11499
intptr_t GetChannel() const
Definition: hps.h:6535
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:4152
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6528
Definition: hps.h:43354
HPS::Type ObjectType() const
Definition: hps.h:50755
ObjectPoint(Point const &in_point)
Definition: hps.h:6217
Definition: hps.h:37976
size_t deferred_sprite_transparent_items
Number of transparent Spriting items deferred.
Definition: hps.h:5209
Definition: hps.h:47966
Definition: hps.h:46631
Definition: hps.h:4694
Definition: hps.h:7169
Definition: hps.h:1372
Definition: hps.h:47422
Definition: hps.h:27442
Point_3D< F > min
Definition: hps.h:3965
SizeUnits
Definition: hps.h:1807
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:47716
static ModifierKeys KeyAlt()
Definition: hps.h:48204
HPS::ByteArray user_data
Definition: hps.h:50699
ExportStartedEvent(Event const &in_event)
Definition: hps.h:49661
Definition: hps.h:1067
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:48551
HPS::Type ObjectType() const
Definition: hps.h:19757
HPS::Type ObjectType() const
Definition: hps.h:10281
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:4142
Definition: hps.h:1766
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:48413
bool NumLock() const
Definition: hps.h:48051
virtual HPS::Type Type() const
Definition: hps.h:13737
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:5179
virtual HPS::Type Type() const
Definition: hps.h:13008
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:48804
HPS::Type ObjectType() const
Definition: hps.h:29000
void RightShift(bool in_state)
Definition: hps.h:48130
HPS::Type ObjectType() const
Definition: hps.h:39582
SizeUnits
Definition: hps.h:1936
DrawingPreference
Definition: hps.h:1547
HPS::Type ObjectType() const
Definition: hps.h:12162
Definition: hps.h:16324
size_t static_not_flattened_big
Number of segments that were not flattened as part of static model generation, because they were cons...
Definition: hps.h:5214
Definition: hps.h:49731
Definition: hps.h:2036
HPS::Type ObjectType() const
Definition: hps.h:49312
void Merge(size_t count, T const *indices, Point_3D< F > const *points)
Definition: hps.h:4217
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:48309
HPS::Type ObjectType() const
Definition: hps.h:39120
virtual HPS::Type Type() const
Definition: hps.h:11928
Cuboid_3D(Rectangle const &that)
Definition: hps.h:4035
std::vector< MaterialPaletteDefinition, Allocator< MaterialPaletteDefinition > > MaterialPaletteDefinitionArray
Array of type HPS::MaterialPaletteDefinition.
Definition: hps.h:6875
std::vector< KeyPath, Allocator< KeyPath > > KeyPathArray
Array of type HPS::KeyPath.
Definition: hps.h:6884
HPS::Type ObjectType() const
Definition: hps.h:52193
Definition: hps.h:26892
Definition: hps.h:21749
std::vector< byte, Allocator< byte > > ByteArray
Array of type HPS::byte.
Definition: hps.h:6860
Definition: hps.h:6178
Definition: hps.h:46706
StaticModel
Definition: hps.h:1136
Definition: hps.h:4720
HPS::Type ObjectType() const
Definition: hps.h:24254
PDFFontPreference
Definition: hps.h:51453
Definition: hps.h:124
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:5183
Definition: hps.h:28967
Definition: hps.h:49119
HideKeyboardEvent()
Definition: hps.h:47970
Definition: hps.h:3963
Definition: hps.h:3960
HPS::Type ObjectType() const
Definition: hps.h:25374
std::vector< ShapeElement, Allocator< ShapeElement > > ShapeElementArray
Array of type HPS::ShapeElement.
Definition: hps.h:6850
Definition: hps.h:20981
Definition: hps.h:7929
char At(size_t in_index) const
Definition: hps.h:7405
HPS::Type ObjectType() const
Definition: hps.h:24049
Definition: hps.h:29846
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6381
void LeftMeta(bool in_state)
Definition: hps.h:48158
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:4070
static MouseButtons ButtonX1()
Definition: hps.h:48618
UpdateCompletedEvent()
Definition: hps.h:47861
HPS::Type ObjectType() const
Definition: hps.h:45801
BackgroundTextureFormat
Definition: hps.h:9282
Definition: hps.h:20641
Definition: hps.h:3639
Definition: hps.h:6788
size_t GetHash() const
void X2(bool in_state)
Definition: hps.h:48571
std::vector< Material::Type, Allocator< Material::Type > > MaterialTypeArray
Array of type HPS::Material::Type.
Definition: hps.h:6866
HPS::Type ObjectType() const
Definition: hps.h:43979
HPS::Type ObjectType() const
Definition: hps.h:40270
std::vector< bool, Allocator< bool > > BoolArray
Array of type bool.
Definition: hps.h:6854
SizeUnits
Definition: hps.h:1784
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:5195
HPS::Type ObjectType() const
Definition: hps.h:13740
Definition: hps.h:16646
Definition: hps.h:2142
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:47664
HPS::Type ObjectType() const
Definition: hps.h:16514
ToleranceUnits
Definition: hps.h:1858
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:48852
HPS::Type ObjectType() const override
Definition: hps.h:9308
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:48893
Background
Definition: hps.h:246
Event * Clone() const
Definition: hps.h:47843
Definition: hps.h:50589
Definition: hps.h:49962
RegionAlignment
Definition: hps.h:1734
HPS::Type ObjectType() const
Definition: hps.h:14292
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
Component
Definition: hps.h:520
Definition: hps.h:446
char const * GetBytes() const
Definition: hps.h:7391
Definition: hps.h:24626
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:47615
static Time GetTime()
Definition: sprk_publish.h:42
Definition: hps.h:2247
Definition: hps.h:29927
Definition: hps.h:41257
HPS::Type ObjectType() const
Definition: hps.h:23404
Definition: hps.h:21989
Time GetTimeStamp() const
Definition: hps.h:6538
Definition: hps.h:2274
Definition: hps.h:4969
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:48097
std::vector< IncludeKey, Allocator< IncludeKey > > IncludeKeyArray
Array of type HPS::IncludeKey.
Definition: hps.h:6885
virtual HPS::Type Type() const
Definition: hps.h:16511
static ModifierKeys KeyLeftAlt()
Definition: hps.h:48245
Default
Definition: hps.h:2039
Definition: sprk_ops.h:20
Definition: hps.h:50561
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6821
FrameSize
Definition: hps.h:212
Definition: hps.h:24023
Definition: hps.h:4851
HPS::Type ObjectType() const
Definition: hps.h:30058
Definition: hps.h:1455
std::vector< Text::MarginUnits, Allocator< Text::MarginUnits > > TextMarginUnitsArray
Array of type HPS::Text::MarginUnits.
Definition: hps.h:6894
Definition: hps.h:20005
HPS::Type ObjectType() const
Definition: hps.h:7147
HPS::Type ObjectType() const
Definition: hps.h:43046
HPS::Type ObjectType() const
Definition: hps.h:49572
Definition: hps.h:887
Definition: hps.h:6048
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:48370
bool Equals(TouchEvent const &in_that) const
Definition: hps.h:48423
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:4198
Shape
Definition: hps.h:1093
static ModifierKeys KeyScrollLock()
Definition: hps.h:48221
Time update_time
Time taken by the last update.
Definition: hps.h:5175
Definition: hps.h:43474
Definition: hps.h:40846
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:5201
HPS::Type ObjectType() const
Definition: hps.h:46215
Definition: hps.h:7919
WarningEvent(Event const &in_event)
Definition: hps.h:47566
Definition: hps.h:42498
Definition: hps.h:52212
HPS::Type ObjectType() const
Definition: hps.h:47331
Definition: hps.h:46051
Definition: hps.h:1824
bool operator==(Touch const &in_that) const
Definition: hps.h:6806
size_t static_segments
Number of segments created while generating static models.
Definition: hps.h:5210
static ModifierKeys KeyShift()
Definition: hps.h:48194
Definition: hps.h:145
bool LeftMeta() const
Definition: hps.h:48087
MaterialPreference
Definition: hps.h:1874
Type
Definition: hps.h:434
HPS::Type ObjectType() const
Definition: hps.h:7064
Definition: hps.h:23191
std::vector< PointArray, Allocator< PointArray > > PointArrayArray
Array of type HPS::PointArray.
Definition: hps.h:6893
Definition: hps.h:1590
Cuboid_3D()
Definition: hps.h:3973
ErrorEvent(Event const &in_event)
Definition: hps.h:47637
Mobility
Definition: hps.h:202
bool Alt() const
Definition: hps.h:48039
HPS::Type ObjectType() const
Definition: hps.h:21007
Definition: hps.h:9173
virtual HPS::Type Type() const
Definition: hps.h:16350
Definition: hps.h:28438
HPS::Type ObjectType() const
Definition: hps.h:44843
static void Free(void *in_pointer)
Definition: hps.h:49515
Definition: hps.h:243
size_t deferred_3d_items_deleted
Number of deferred items deleted during the last update.
Definition: hps.h:5206
Definition: hps.h:47897
HPS::Type ObjectType() const
Definition: hps.h:7592
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:4183
void Meta(bool in_state)
Definition: hps.h:48114
Definition: hps.h:7120
HPS::Type ObjectType() const
Definition: hps.h:26724
HPS::Type ObjectType() const
Definition: hps.h:51049
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5473
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6464
Definition: hps.h:30035
Definition: hps.h:50307
HPS::Type ObjectType() const
Definition: hps.h:24525
Definition: hps.h:9261
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:47763
HPS::Type ObjectType() const
Definition: hps.h:52071
HPS::Type ObjectType() const
Definition: hps.h:36527
Definition: hps.h:23812
size_t static_not_drawing
Number of segments that are part of the static model, that do not contribute towards drawing...
Definition: hps.h:5212
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:48339
Definition: hps.h:4793
TimerTickEvent(Event const &in_event)
Definition: hps.h:47391
virtual HPS::Type Type() const
Definition: hps.h:18850
Definition: hps.h:52048
Definition: hps.h:6209
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6423
std::vector< ObjectPoint, Allocator< ObjectPoint > > ObjectPointArray
Array of type HPS::ObjectPoint.
Definition: hps.h:6830
Definition: hps.h:13714
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5479
bool IsConsumable() const
Definition: hps.h:6541
ImportCompletedEvent()
Definition: hps.h:49735
Definition: hps.h:19054
Definition: hps.h:2371
std::vector< TrimElement, Allocator< TrimElement > > TrimElementArray
Array of type HPS::TrimElement.
Definition: hps.h:6883
Definition: hps.h:27893
bool X1() const
Definition: hps.h:48536
bool LeftControl() const
Definition: hps.h:48071
InformationEvent()
Definition: hps.h:47482
KeyPath & PushBack(Key const &in_key)
Definition: hps.h:43305
Definition: hps.h:12728
virtual HPS::Type Type() const
Definition: hps.h:10822
HPS::Type ObjectType() const
Definition: hps.h:49040
Definition: hps.h:47937
Definition: hps.h:15467
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:5182
Definition: hps.h:12137
Infinite line which extends infinitely in both directions along a vector.
Definition: hps.h:52485
Event * Clone() const
Definition: hps.h:47957
Definition: hps.h:1893
Definition: hps.h:50267
HPS::Type ObjectType() const
Definition: hps.h:46657
bool LeftAlt() const
Definition: hps.h:48079
Point_3D< F > max
Definition: hps.h:3967
Definition: hps.h:12446
Definition: hps.h:23564
HPS::Type ObjectType() const
Definition: hps.h:42521
size_t GetWStrLength() const
Definition: hps.h:7384
Definition: hps.h:15590
HPS::Type ObjectType() const
Definition: hps.h:20031
HPS::Type ObjectType() const
Definition: hps.h:51740
MouseEvent()
Definition: hps.h:48659
HPS::Type ObjectType() const
Definition: hps.h:15889
Definition: hps.h:15685
static ModifierKeys KeyLeftControl()
Definition: hps.h:48237
Definition: hps.h:22610
HPS::Type ObjectType() const
Definition: hps.h:40196
Definition: hps.h:30308
Definition: hps.h:1087
HPS::Type ObjectType() const
Definition: hps.h:15287
Definition: hps.h:13621
Scope
Definition: hps.h:562
HPS::Type ObjectType() const
Definition: hps.h:41205
HPS::Type ObjectType() const
Definition: hps.h:9194
std::vector< PortfolioKey, Allocator< PortfolioKey > > PortfolioKeyArray
Array of type HPS::PortfolioKey.
Definition: hps.h:6857
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:49369
Definition: hps.h:36493
Definition: hps.h:13962
Quality
Definition: hps.h:1077
static const float Infinity
Definition: hps.h:2426
HPS::Type ObjectType() const
Definition: hps.h:45984
Definition: hps.h:6147
std::vector< ImageDefinition, Allocator< ImageDefinition > > ImageDefinitionArray
Array of type HPS::ImageDefinition.
Definition: hps.h:6873
ReferenceFrame
Definition: hps.h:1611
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2439
HPS::Type ObjectType() const
Definition: hps.h:12617
bool Right() const
Definition: hps.h:48528
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6820
SizeToleranceUnits
Definition: hps.h:1687
HPS::Type ObjectType() const
Definition: hps.h:12753
Action
Definition: hps.h:48648
The leader line position is supplied in Object Space.
HPS::Type ObjectType() const
Definition: hps.h:41348
virtual HPS::Type Type() const
Definition: hps.h:46654
HPS::Type ObjectType() const
Definition: hps.h:24959
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:4162
Definition: hps.h:49017
Definition: hps.h:9221
AppendMode
Definition: hps.h:341
HPS::Type ObjectType() const
Definition: hps.h:43204
Definition: hps.h:44349
Definition: hps.h:42386
bool IsValid() const
Definition: hps.h:7355
Definition: hps.h:11905
Cuboid_3D(size_t count, T const *indices, Point_3D< F > const *points)
Definition: hps.h:4020
HPS::Type ObjectType() const
Definition: hps.h:49142
std::vector< PointArrayArray, Allocator< PointArrayArray > > PointArrayArrayArray
Array of type HPS::PointArrayArray.
Definition: hps.h:6895
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:4119
HPS::Type ObjectType() const
Definition: hps.h:38927
HPS::Type ObjectType() const
Definition: hps.h:43605
virtual HPS::Type Type() const
Definition: hps.h:13581
Border
Definition: hps.h:271
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:5188
Definition: hps.h:51325
HPS::Type ObjectType() const
Definition: hps.h:45342
Definition: hps.h:2832
Definition: hps.h:51021
Definition: hps.h:574
KeyboardEvent(Event const &in_event)
Definition: hps.h:48824
void RightControl(bool in_state)
Definition: hps.h:48138
size_t GetLength() const
Definition: hps.h:7376
Definition: hps.h:23873
Definition: hps.h:39709
Event * Clone() const
Definition: hps.h:48404
HPS::Type ObjectType() const
Definition: hps.h:44249
std::vector< MaterialKit, Allocator< MaterialKit > > MaterialKitArray
Array of type HPS::MaterialKit.
Definition: hps.h:6863
UpdateStatus
Definition: hps.h:165
Definition: hps.h:2745
HPS::Type ObjectType() const
Definition: hps.h:17584
Definition: hps.h:33773
bool None() const
Definition: hps.h:48520
Definition: hps.h:42433
Definition: hps.h:51368
HPS::Type ObjectType() const
Definition: hps.h:15616
HPS::Type ObjectType() const
Definition: hps.h:32363
Definition: hps.h:4607
CoordinateSpace
Definition: hps.h:1773
HPS::Type ObjectType() const
Definition: hps.h:43552
HPS::Type ObjectType() const
Definition: hps.h:39784
Definition: hps.h:42710
HPS::Type ObjectType() const
Definition: hps.h:45267
Definition: hps.h:41818
GreekingMode
Definition: hps.h:1725
FocusLostEvent()
Definition: hps.h:47772
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:48862
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:4234
Definition: hps.h:10344
Definition: hps.h:52292
Definition: hps.h:45140
virtual HPS::Type Type() const
Definition: hps.h:11496
Definition: hps.h:6335
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:47685
Definition: hps.h:1107
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2447
std::vector< RGBColor, Allocator< RGBColor > > RGBColorArray
Array of type HPS::RGBColor.
Definition: hps.h:6841
virtual HPS::Type Type() const
Definition: hps.h:15401
Definition: hps.h:49546
Definition: hps.h:48642
Space
Definition: hps.h:2254
ShowKeyboardEvent(Event const &in_event)
Definition: hps.h:47947
Event * Clone() const
Definition: hps.h:47886
virtual intptr_t Freshen() const
Definition: hps.h:49774
HPS::Type ObjectType() const
Definition: hps.h:32283
ErrorEvent()
Definition: hps.h:47624
Definition: hps.h:47692
HPS::Type ObjectType() const
Definition: hps.h:40100
std::vector< UTF8Array, Allocator< UTF8Array > > UTF8ArrayArray
Array of type HPS::UTF8Array.
Definition: hps.h:6853
Definition: hps.h:7039
Definition: hps.h:39840
bool Left() const
Definition: hps.h:48524
virtual HPS::Type Type() const
Definition: hps.h:22012
bool Empty() const
Definition: hps.h:7362
static ModifierKeys KeyRightMeta()
Definition: hps.h:48249
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:6040
Definition: hps.h:39897
Definition: hps.h:49701
Definition: hps.h:41589
RelationTest
Definition: hps.h:396
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:47868
HPS::Type ObjectType() const
Definition: hps.h:38539
Definition: hps.h:48343
HPS::Type ObjectType() const
Definition: hps.h:41795
Definition: hps.h:2386
HPS::Type ObjectType() const
Definition: hps.h:40786
Definition: hps.h:10145
Definition: hps.h:26701
Definition: hps.h:13363
Definition: hps.h:24372
HPS::Type ObjectType() const
Definition: hps.h:22253
HPS::Type ObjectType() const
Definition: hps.h:6182
RenderingAlgorithm
Definition: hps.h:51446
Definition: hps.h:47198
static ModifierKeys KeyRightControl()
Definition: hps.h:48233
HPS::Type ObjectType() const
Definition: hps.h:42467
Definition: hps.h:43518
Definition: hps.h:50686
Definition: hps.h:1801
Renderer
Definition: hps.h:1646
HPS::Type ObjectType() const
Definition: hps.h:45163
HPS::Type ObjectType() const
Definition: hps.h:45910
TextInputEvent(Event const &in_event)
Definition: hps.h:47802
Definition: hps.h:1543
HPS::Type ObjectType() const
Definition: hps.h:28115
std::vector< Line::SizeUnits, Allocator< Line::SizeUnits > > LineSizeUnitsArray
Array of type HPS::Line::SizeUnits.
Definition: hps.h:6868
Method
Definition: hps.h:1500
GatheringLevel
Definition: hps.h:1882
Definition: hps.h:327
Definition: hps.h:1475
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:47593
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:47410
HPS::Type ObjectType() const
Definition: hps.h:16671
bool CapsLock() const
Definition: hps.h:48047
Definition: hps.h:50468
ColorSource
Definition: hps.h:2070
Definition: hps.h:47788
std::vector< ShapeDefinition, Allocator< ShapeDefinition > > ShapeDefinitionArray
Array of type HPS::ShapeDefinition.
Definition: hps.h:6879
CappingLevel
Definition: hps.h:1840
Definition: hps.h:19731
std::vector< LinePatternParallelKit, Allocator< LinePatternParallelKit > > LinePatternParallelKitArray
Array of type HPS::LinePatternParallelKit.
Definition: hps.h:6865
HPS::Type ObjectType() const
Definition: hps.h:20666
Definition: hps.h:41070
Definition: hps.h:49715
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:48898
HPS::Type ObjectType() const
Definition: hps.h:13389
ResolutionUnits
Definition: hps.h:51430
Relation
Definition: hps.h:386
Definition: hps.h:1494
HPS::Type ObjectType() const
Definition: hps.h:42420
WorldPoint(Point const &in_point)
Definition: hps.h:6259
HPS::Type ObjectType() const
Definition: hps.h:28610
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:48472
Definition: hps.h:52255
size_t display_list_compilations
Number of display lists compiled during the last update.
Definition: hps.h:5196
HPS::Type ObjectType() const
Definition: hps.h:27549
std::vector< DVector, Allocator< DVector > > DVectorArray
Array of type HPS::DVector.
Definition: hps.h:6838
Definition: hps.h:49589
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:48497
virtual HPS::Type Type() const
Definition: hps.h:23587
std::vector< Drawing::ClipSpace, Allocator< Drawing::ClipSpace > > ClipSpaceArray
Array of type HPS::Drawing::ClipSpace.
Definition: hps.h:6896
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2665
Definition: hps.h:25552
Definition: hps.h:39401
Definition: hps.h:20114
void LeftAlt(bool in_state)
Definition: hps.h:48150
TouchEvent(Event const &in_event)
Definition: hps.h:48385
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7487
Definition: hps.h:5456
Definition: hps.h:45416
Definition: hps.h:52287
Definition: hps.h:41675
size_t save_region_count
Number of framebuffer regions saved during the last update.
Definition: hps.h:5202
Definition: hps.h:40066
HPS::Type ObjectType() const
Definition: hps.h:27794
Definition: hps.h:4546
HPS::Type ObjectType() const
Definition: hps.h:45440
std::vector< GlyphElement, Allocator< GlyphElement > > GlyphElementArray
Array of type HPS::GlyphElement.
Definition: hps.h:6849
virtual intptr_t Freshen() const
Definition: hps.h:47416
void LeftControl(bool in_state)
Definition: hps.h:48142
Definition: hps.h:7300
HPS::Type ObjectType() const
Definition: hps.h:27273
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:6057
Definition: hps.h:26977
HPS::Type ObjectType() const
Definition: hps.h:40691
Definition: hps.h:6294
Definition: hps.h:48488
virtual intptr_t Freshen() const
Definition: hps.h:48761
Definition: hps.h:27761
HPS::Type ObjectType() const
Definition: hps.h:9010
Definition: hps.h:30533
virtual HPS::Type Type() const
Definition: hps.h:23214
HPS::Type ObjectType() const
Definition: hps.h:38128
std::vector< float, Allocator< float > > FloatArray
Array of type float.
Definition: hps.h:6845
Definition: hps.h:6913
HPS::Type ObjectType() const
Definition: hps.h:52514
Definition: hps.h:45319
Definition: hps.h:9271
virtual HPS::Type Type() const
Definition: hps.h:23835
Definition: hps.h:50214
HPS::Type ObjectType() const
Definition: hps.h:49392
Event * Clone() const
Definition: hps.h:47655
Grid composed of quadrilaterals.
FrameOptions
Definition: hps.h:220
Definition: hps.h:6252
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:48899
Definition: hps.h:47378
Definition: hps.h:46188
HPS::Type ObjectType() const
Definition: hps.h:51488
Definition: hps.h:44399
Definition: hps.h:28587
Definition: hps.h:48904
std::vector< MatrixKit, Allocator< MatrixKit > > MatrixKitArray
Array of type HPS::MatrixKit.
Definition: hps.h:6898
Operation
Definition: hps.h:461
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:6031
float blue
Definition: hps.h:4612
HPS::Type ObjectType() const
Definition: hps.h:22636
Definition: hps.h:47768
HPS::Type ObjectType() const
Definition: hps.h:23748
Definition: sprk_dwg.h:43
HPS::Type ObjectType() const
Definition: hps.h:23838
Driver
Definition: hps.h:153
Multiline strings will be left justified.
std::vector< NamedStyleDefinition, Allocator< NamedStyleDefinition > > NamedStyleDefinitionArray
Array of type HPS::NamedStyleDefinition.
Definition: hps.h:6874
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7505
PixelPoint(Point const &in_point)
Definition: hps.h:6467
std::vector< InnerPixelPoint, Allocator< InnerPixelPoint > > InnerPixelPointArray
Array of type HPS::InnerPixelPoint.
Definition: hps.h:6834
Mode
Definition: hps.h:1830
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:49685
HPS::Type ObjectType() const
Definition: hps.h:26925
static ModifierKeys KeyRightShift()
Definition: hps.h:48225
Definition: hps.h:19871
Definition: hps.h:23724
std::vector< WindowPoint, Allocator< WindowPoint > > WindowPointArray
Array of type HPS::WindowPoint.
Definition: hps.h:6835
HPS::Type ObjectType() const
Definition: hps.h:19896
Default
Definition: hps.h:2080
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:48092
Definition: hps.h:51277
size_t display_list_text_lines_3d_count
Number of lines generated from text that were drawn from display lists during the last update...
Definition: hps.h:5192
Event * Clone() const
Definition: hps.h:47927
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:5194
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:5190
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:48723
size_t display_list_text_triangles_3d_count
Number of faces generated from text that were drawn from display lists during the last update...
Definition: hps.h:5193
Code
Definition: hps.h:99
HPS::Type ObjectType() const
Definition: hps.h:41413
UpdateCompletedEvent(Time in_update_time, Window::UpdateStatus in_update_status)
Definition: hps.h:47864
virtual HPS::Type Type() const
Definition: hps.h:19754
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:48769
Definition: hps.h:16019
Algorithm
Definition: hps.h:1379
HPS::Type ObjectType() const
Definition: hps.h:51306
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:40713
Definition: hps.h:47857
HPS::Type ObjectType() const
Definition: hps.h:42869
Definition: hps.h:41435
Definition: hps.h:50868
static Quaternion ComputeRotation(float in_degrees, HPS::Vector const &in_axis)
Definition: hps.h:5130
HPS::Type ObjectType() const
Definition: hps.h:49496
virtual HPS::Type Type() const
Definition: hps.h:12614
bool ScrollLock() const
Definition: hps.h:48055
Definition: hps.h:2054
std::vector< int, Allocator< int > > IntArray
Array of type int.
Definition: hps.h:6840
Definition: hps.h:35166
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:5180
std::vector< GlyphDefinition, Allocator< GlyphDefinition > > GlyphDefinitionArray
Array of type HPS::GlpyhDefinition.
Definition: hps.h:6876
Fastest ambient occlusion but lower quality.
virtual HPS::Type Type() const
Definition: hps.h:20410
Definition: hps.h:1392
Definition: hps.h:15262
ImageFormat
Definition: hps.h:228
Definition: hps.h:50241
Definition: hps.h:50441
HPS::Type ObjectType() const
Definition: hps.h:41093
Definition: hps.h:13883
Definition: hps.h:50001
HPS::Type ObjectType() const
Definition: hps.h:6152
Definition: hps.h:11652
ExportStartedEvent()
Definition: hps.h:49652
Definition: hps.h:7549
Definition: hps.h:49226
StandAloneWindowEvent()
Definition: hps.h:47707
Quaternion Squad(Quaternion const &in_right, Quaternion const &in_control1, Quaternion const &in_control2, float in_fraction) const
Definition: hps.h:5105
HPS::Type ObjectType() const
Definition: hps.h:43388
Definition: hps.h:47995
Definition: hps.h:45606
TextInputEvent(char const *in_text)
Definition: hps.h:47798
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:47549
Projection
Definition: hps.h:1461
SizeUnits
Definition: hps.h:51423
Definition: hps.h:50428
bool X2() const
Definition: hps.h:48540
Event * Clone() const
Definition: hps.h:47466
HPS::Type ObjectType() const
Definition: hps.h:29663
HPS::Type ObjectType() const
Definition: hps.h:30566
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:48667
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:6003
Preference
Definition: hps.h:1655
HPS::Type ObjectType() const
Definition: hps.h:21773
InsetBehavior
Definition: hps.h:1949
HPS::Type ObjectType() const
Definition: hps.h:45638
HPS::Type ObjectType() const
Definition: hps.h:44422
float static_density
The average number of geometry per segment in the static models.
Definition: hps.h:5211
Definition: hps.h:38904
Definition: hps.h:52164
void Control(bool in_state)
Definition: hps.h:48106
Definition: hps.h:24492
Definition: hps.h:51712
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:4084
Algorithm
Definition: hps.h:1509
Definition: hps.h:3100
Interpolation
Definition: hps.h:1020
Definition: hps.h:19141
Definition: hps.h:48285
Object space units ignoring any scaling components in modelling matrices.
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:47614
Preference
Definition: hps.h:1531
The base class of all HPS exceptions.
Definition: hps.h:5995
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:48379
HPS::Type ObjectType() const
Definition: hps.h:11275
std::vector< Style::Type, Allocator< Style::Type > > StyleTypeArray
Array of type HPS::Style::Type.
Definition: hps.h:6882
HPS::Type ObjectType() const
Definition: hps.h:13802
std::vector< StyleKey, Allocator< StyleKey > > StyleKeyArray
Array of type HPS::StyleKey.
Definition: hps.h:6892
Definition: hps.h:6502
Definition: hps.h:42971
HPS::Type ObjectType() const
Definition: hps.h:39878
InformationEvent(Event const &in_event)
Definition: hps.h:47495
Definition: hps.h:14267
void Invalidate()
Definition: hps.h:4052
Definition: hps.h:26071
HPS_INLINE bool IsValid() const
Definition: hps.h:4040
Definition: hps.h:44817
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:6054
Definition: hps.h:41379
HPS::Type ObjectType() const
Definition: hps.h:46078
Definition: hps.h:49289
std::vector< UTF8, Allocator< UTF8 > > UTF8Array
Array of type HPS::UTF8.
Definition: hps.h:6852
The geometry inside the clip region is drawn. Everything outside of it is clipped.
std::vector< HPS::Type, Allocator< HPS::Type > > TypeArray
Array of type HPS::Type.
Definition: hps.h:6905
HPS::Type ObjectType() const
Definition: hps.h:40618
Justification
Definition: hps.h:1985
size_t restore_region_count
Number of framebuffer regions restored during the last update.
Definition: hps.h:5203
Definition: hps.h:50508
Material Texture ChannelMapping.
GreekingUnits
Definition: hps.h:1713
virtual HPS::Type Type() const
Definition: hps.h:24046
HPS::Type ObjectType() const
Definition: hps.h:12470
Definition: hps.h:6460
Value
Definition: hps.h:1481
HPS::Type ObjectType() const
Definition: hps.h:41618
SizeUnits
Definition: hps.h:1555
HPS::ByteArray non_db_user_data
Definition: hps.h:49599
Definition: hps.h:409
HPS::Type ObjectType() const
Definition: hps.h:23006
Event * Clone() const
Definition: hps.h:48843
The vertex colors applied to faces.
ClipOperation
Definition: hps.h:1352
std::vector< Touch, Allocator< Touch > > TouchArray
Array of type HPS::Touch.
Definition: hps.h:6887
std::vector< InnerWindowPoint, Allocator< InnerWindowPoint > > InnerWindowPointArray
Array of type HPS::InnerWindowPoint.
Definition: hps.h:6833
std::vector< intptr_t, Allocator< intptr_t > > IntPtrTArray
Array of type intptr_t.
Definition: hps.h:6889
virtual bool Empty() const
Definition: hps.h:6104
MarginUnits
Definition: hps.h:1700
Definition: hps.h:38771
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:48294
std::vector< Shell::Relation, Allocator< Shell::Relation > > ShellRelationArray
Array of type HPS::ShelL::Relation.
Definition: hps.h:6891
float green
Definition: hps.h:4611
HPS::Type ObjectType() const
Definition: hps.h:18757
ImportCompletedEvent(Event const &in_event)
Definition: hps.h:49744
size_t GetHash() const
virtual HPS::Type ObjectType() const
Definition: hps.h:6098
Algorithm
Definition: hps.h:1426
HPS::Type ObjectType() const
Definition: hps.h:14794
Definition: hps.h:41521
HandleResult
Definition: hps.h:47362
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:5181
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:43434
Definition: hps.h:11474
Status
Definition: hps.h:6508
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6384
HPS::Type ObjectType() const
Definition: hps.h:21311
ImportStatusEvent(Event const &in_event)
Definition: hps.h:47912
std::vector< int64_t, HPS::Allocator< int64_t > > Int64Array
Array of type int64_t.
Definition: hps.h:6900
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:48004
Component
Definition: hps.h:415
Definition: sprk_parasolid.h:39
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6800
Type
Definition: hps.h:333
Definition: hps.h:49795
static const float NegativeInfinity
Definition: hps.h:2428
Definition: hps.h:49886
HighlightEvent(Event const &in_event)
Definition: hps.h:47449
Event * Clone() const
Definition: hps.h:47513
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7496
Justification
Definition: hps.h:1619
HPS::Type ObjectType() const
Definition: hps.h:27916
Definition: hps.h:24150
TextInputEvent()
Definition: hps.h:47792
HPS::Type ObjectType() const
Definition: hps.h:25321
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:48771
InnerWindowPoint(Point const &in_point)
Definition: hps.h:6343
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:47544
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:5118
InnerConeUnits
Definition: hps.h:493
std::vector< KeyboardCode, Allocator< KeyboardCode > > KeyboardCodeArray
Array of type HPS::KeyboardCode.
Definition: hps.h:6886
Definition: hps.h:47303
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:4002
virtual HPS::Type Type() const
Definition: hps.h:39117
Definition: hps.h:13777
Event * Clone() const
Definition: hps.h:48704
virtual HPS::Type Type() const
Definition: hps.h:44840
HPS::Type ObjectType() const
Definition: hps.h:44374
virtual HPS::Type Type() const
Definition: hps.h:39579
std::vector< Key, Allocator< Key > > KeyArray
Array of type HPS::Key.
Definition: hps.h:6856
void Alt(bool in_state)
Definition: hps.h:48110
HPS::Type ObjectType() const
Definition: hps.h:40331
Definition: hps.h:2161
Buttons
Definition: hps.h:48628
HPS::Type ObjectType() const
Definition: hps.h:19166
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:48796
HideKeyboardEvent(Event const &in_event)
Definition: hps.h:47976
Definition: hps.h:46899
Definition: hps.h:27166
Definition: hps.h:93
virtual HPS::Type Type() const
Definition: hps.h:6150
bool operator!=(ShapePoint const &in_that) const
Definition: hps.h:7030
HPS::Type ObjectType() const
Definition: hps.h:13646
Granularity
Definition: hps.h:1439
HPS::Type ObjectType() const
Definition: hps.h:15710
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6256
Percentage of the requested font height.
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7478
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:48447
HPS::Type ObjectType() const
Definition: hps.h:7958
ShowKeyboardEvent()
Definition: hps.h:47941
Definition: hps.h:26426
Definition: hps.h:49648
Style Append Mode.
HPS::SegmentKey & segment_key
Definition: hps.h:49641
std::vector< Plane, Allocator< Plane > > PlaneArray
Array of type HPS::Plane.
Definition: hps.h:6839
bool Meta() const
Definition: hps.h:48043
Definition: hps.h:49603
HPS::Type ObjectType() const
Definition: hps.h:46550
Definition: hps.h:39761
Definition: hps.h:1315
HPS::Type ObjectType() const
Definition: hps.h:23897
Channel
Definition: hps.h:910
HPS::Type ObjectType() const
Definition: hps.h:39687
std::vector< unsigned int, Allocator< unsigned int > > UnsignedIntArray
Array of type unsigned int.
Definition: hps.h:6843
HPS::Type ObjectType() const
Definition: hps.h:27199
void Middle(bool in_state)
Definition: hps.h:48563
Definition: hps.h:32340
Event * Clone() const
Definition: hps.h:49759
HPS::Type ObjectType() const
Definition: hps.h:43508
Definition: hps.h:5173
static Quaternion ComputeRotation(float in_x, float in_y, float in_z)
Definition: hps.h:5152
Action
Definition: hps.h:48783
Definition: hps.h:50535
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:48546
HPS::Type ObjectType() const
Definition: hps.h:15404
HPS::Type ObjectType() const
Definition: hps.h:28190
Type
Definition: hps.h:1178
bool RightControl() const
Definition: hps.h:48067
HPS::Type ObjectType() const
Definition: hps.h:32151
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:22015
std::vector< char, Allocator< char > > CharArray
Array of type char.
Definition: hps.h:6858
HPS::Type ObjectType() const
Definition: hps.h:6582
InterpolationAlgorithm
Definition: hps.h:1578
size_t ClickCount
The number of clicks received.
Definition: hps.h:48773
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
void Reset()
Definition: hps.h:7371
Definition: hps.h:38643
HPS::Type ObjectType() const
Definition: hps.h:40747
Action
Definition: hps.h:47698
virtual HPS::Type Type() const
Definition: hps.h:13906
Code
Definition: hps.h:130
HPS::Type ObjectType() const
Definition: hps.h:39424
HPS::Type ObjectType() const
Definition: hps.h:38677
Preference
Definition: hps.h:2296
virtual HPS::Type Type() const
Definition: hps.h:14148
Definition: hps.h:45243
Definition: hps.h:50702
bool RightShift() const
Definition: hps.h:48059
static ModifierKeys KeyNumLock()
Definition: hps.h:48217
MouseEvent(Event const &in_event)
Definition: hps.h:48682
HPS::Type ObjectType() const
Definition: hps.h:19079
Definition: hps.h:2181
Handedness
Definition: hps.h:1321
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:4176
static MouseButtons ButtonLeft()
Definition: hps.h:48606
std::vector< CameraPoint, Allocator< CameraPoint > > CameraPointArray
Array of type HPS::CameraPoint.
Definition: hps.h:6832
bool Middle() const
Definition: hps.h:48532
HPS::Type ObjectType() const
Definition: hps.h:17841
HPS::Type ObjectType() const
Definition: hps.h:24398
Type
Definition: hps.h:452
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:5177
static MouseButtons ButtonMiddle()
Definition: hps.h:48614
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:4131
Definition: hps.h:75
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:48362
Capping
Definition: hps.h:528
static intptr_t ClassID()
Definition: hps.h:6131
size_t deferred_3d_items_created
Number of deferred items created during the last update.
Definition: hps.h:5205
virtual bool Equals(TextInputEvent const &in_that) const
Definition: hps.h:47818
HighlightEvent()
Definition: hps.h:47433
HPS::Type ObjectType() const
Definition: hps.h:24649
Definition: hps.h:49821
Definition: hps.h:21286
Definition: hps.h:31989
bool operator==(ShapeCoordinate const &in_that) const
Definition: hps.h:6966
HPS::Type ObjectType() const
Definition: hps.h:41916
Definition: hps.h:18828
void RightAlt(bool in_state)
Definition: hps.h:48146
HPS::Type ObjectType() const
Definition: hps.h:30331
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:48471
HPS::Type ObjectType() const
Definition: hps.h:46127
UpdateType
Definition: hps.h:177
Definition: hps.h:9331
Type
Definition: hps.h:597
Component
Definition: hps.h:360
Format
Definition: hps.h:42715
std::vector< ConditionalExpression, Allocator< ConditionalExpression > > ConditionalExpressionArray
Array of type HPS::ConditionalExpression.
Definition: hps.h:6870
Definition: hps.h:51460
CuttingLevel
Definition: hps.h:1866
static ModifierKeys KeyControl()
Definition: hps.h:48199
SizeUnits
Definition: hps.h:1675
virtual HPS::Type Type() const
Definition: hps.h:15613
HPS::Type ObjectType() const
Definition: hps.h:39926
Level
Definition: hps.h:1398
std::vector< IntRectangle, Allocator< IntRectangle > > IntRectangleArray
Array of type HPS::IntRectangle.
Definition: hps.h:6880
Definition: hps.h:6013
Definition: hps.h:7847
Definition: hps.h:50361
Default
Definition: hps.h:2016
StandAloneWindowEvent(Action in_action)
Definition: hps.h:47712
HPS::Type ObjectType() const
Definition: hps.h:14151
Definition: hps.h:37746
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:5198
Definition: hps.h:12305
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:47543
virtual intptr_t Freshen() const
Definition: hps.h:6532
The vertex colors applied to faces.
Definition: hps.h:38504
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:5184
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4307
virtual HPS::Type Type() const
Definition: hps.h:19076
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4263
HPS::Type ObjectType() const
Definition: hps.h:13255
std::vector< TrimKit, Allocator< TrimKit > > TrimKitArray
Array of type HPS::TrimKit.
Definition: hps.h:6855
Definition: hps.h:38365
HPS::Type ObjectType() const
Definition: hps.h:26648
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:5189
Definition: hps.h:354
HPS::Type ObjectType() const
Definition: hps.h:23217
Definition: hps.h:16488
Definition: hps.h:24230
std::vector< sbyte, Allocator< sbyte > > SByteArray
Array of type HPS::sbyte.
Definition: hps.h:6862
std::vector< Drawing::ClipOperation, Allocator< Drawing::ClipOperation > > ClipOperationArray
Array of type HPS::Drawing::ClipOperation.
Definition: hps.h:6897
HPS::Type ObjectType() const
Definition: hps.h:50891
Definition: hps.h:926
std::vector< Point, Allocator< Point > > PointArray
Array of type HPS::Point.
Definition: hps.h:6829
Time static_time
Time taken to create the static model(s) during the last update.
Definition: hps.h:5176
Definition: hps.h:40657
HPS::Type ObjectType() const
Definition: hps.h:13011
Definition: hps.h:49539
HPS::Type ObjectType() const
Definition: hps.h:46270
AreaUnits
Definition: hps.h:1522
Definition: hps.h:40308
HandednessOptimization
Definition: hps.h:377
size_t deferred_inplace_items
Number of InPlace items deferred.
Definition: hps.h:5207
static ModifierKeys KeyRightAlt()
Definition: hps.h:48241
HPS::Type ObjectType() const
Definition: hps.h:26104
HPS::Type ObjectType() const
Definition: hps.h:10170
Definition: hps.h:40595
std::vector< Line::CoordinateSpace, Allocator< Line::CoordinateSpace > > LineCoordinateSpaceArray
Array of type HPS::Line::CoordinateSpace.
Definition: hps.h:6901
HPS::Type ObjectType() const
Definition: hps.h:20139
Definition: hps.h:27250
Definition: hps.h:9560
HPS::Type ObjectType() const
Definition: hps.h:30668
Definition: hps.h:11250
HPS::Type ObjectType() const
Definition: hps.h:10369
bool Equals(ShapePoint const &in_that) const
Definition: hps.h:7020
HPS::Type ObjectType() const
Definition: hps.h:35189
virtual HPS::Type Type() const
Definition: hps.h:20028
RegionFitting
Definition: hps.h:1751
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4292
WindowPoint(Point const &in_point)
Definition: hps.h:6426
Definition: hps.h:12591
Alignment
Definition: hps.h:1596
Definition: hps.h:9254
HPS::Key & key
Definition: hps.h:49627
Definition: hps.h:47478
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:45778
virtual HPS::Type Type() const
Definition: hps.h:10278
Definition: hps.h:24926
Definition: hps.h:40019
HPS::Type ObjectType() const
Definition: hps.h:26449
std::vector< WorldPoint, Allocator< WorldPoint > > WorldPointArray
Array of type HPS::WorldPoint.
Definition: hps.h:6831
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4248
std::vector< RGBAColor, Allocator< RGBAColor > > RGBAColorArray
Array of type HPS::RGBAColor.
Definition: hps.h:6842
Definition: hps.h:30645
Definition: hps.h:25288
Definition: hps.h:556
Definition: hps.h:29130
Type
Definition: hps.h:893
CappingUsage
Definition: hps.h:1849
HPS::Type ObjectType() const
Definition: hps.h:43334
Definition: hps.h:945
ModifierKeys()
Definition: hps.h:47999
Definition: hps.h:28167
static ModifierKeys KeyLeftShift()
Definition: hps.h:48229
Definition: hps.h:1930
std::vector< HighlightState, Allocator< HighlightState > > HighlightStateArray
Array of type HPS::HighlightState.
Definition: hps.h:6903
Definition: hps.h:25649
Definition: hps.h:31359
size_t deferred_sprite_items
Number of Spriting items deferred.
Definition: hps.h:5208
Definition: hps.h:49617
HPS::Type ObjectType() const
Definition: hps.h:25585
HPS::Type ObjectType() const
Definition: hps.h:16353
Tiling
Definition: hps.h:1001
Material Texture ChannelMapping.
Definition: hps.h:47620
TouchEvent()
Definition: hps.h:48356
Definition: hps.h:44050
HPS::Type ObjectType() const
Definition: hps.h:7201
void LeftShift(bool in_state)
Definition: hps.h:48134
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:47522
std::vector< AttributeLock::Type, Allocator< AttributeLock::Type > > AttributeLockTypeArray
Array of type HPS::AttributeLock.
Definition: hps.h:6881
HPS::Type ObjectType() const
Definition: hps.h:48927
Modifiers
Definition: hps.h:48259
Definition: hps.h:514
Definition: hps.h:10799
BackgroundPreference
Definition: hps.h:51439
std::vector< TextureDefinition, Allocator< TextureDefinition > > TextureDefinitionArray
Array of type HPS::TexureDefinition.
Definition: hps.h:6871
Definition: hps.h:43177
HPS::Type ObjectType() const
Definition: hps.h:25151
virtual HPS::Type Type() const
Definition: hps.h:24395
virtual HPS::Type Type() const
Definition: hps.h:14791
HPS::Type ObjectType() const
Definition: hps.h:49249
Definition: hps.h:19569
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4277
Definition: hps.h:41752
Definition: hps.h:3411
HPS::Type ObjectType() const
Definition: hps.h:40869
HPS::Type ObjectType() const
Definition: hps.h:12331
virtual HPS::Type Type() const
Definition: hps.h:17838
WarningEvent()
Definition: hps.h:47553
std::vector< CubeMapDefinition, Allocator< CubeMapDefinition > > CubeMapDefinitionArray
Array of type HPS::CubeMapDefinition.
Definition: hps.h:6872
bool LeftShift() const
Definition: hps.h:48063
ModifierKeys GetModifierKeys() const
Definition: hps.h:48334
Definition: hps.h:28082
HPS::Type ObjectType() const
Definition: hps.h:27000
Touch()
Definition: hps.h:6794
Definition: hps.h:13558
std::vector< GeometryKey, Allocator< GeometryKey > > GeometryKeyArray
Array of type HPS::GeometryKey.
Definition: hps.h:6890
Channel
Definition: hps.h:932
std::vector< wchar_t, Allocator< wchar_t > > WCharArray
Array of type wchar_t.
Definition: hps.h:6859
HPS::Type ObjectType() const
Definition: hps.h:39233
Sorting
Definition: hps.h:1407
Definition: hps.h:40752
HPS::Type ObjectType() const
Definition: hps.h:25672
ChannelMapping
Definition: hps.h:1047
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:5185
Definition: hps.h:38111
Definition: hps.h:46244
Definition: hps.h:1173
HPS::Type ObjectType() const
Definition: hps.h:38010
ToleranceUnits
Definition: hps.h:369
HPS::Type ObjectType() const
Definition: hps.h:7874
Kit & operator=(Kit &&in_that)
Definition: hps.h:6200
HPS::Type ObjectType() const
Definition: hps.h:13584
float red
Definition: hps.h:4610
HPS::Type ObjectType() const
Definition: hps.h:30258
Event * Clone() const
Definition: hps.h:48300
Definition: hps.h:13469
virtual intptr_t Freshen() const
Definition: hps.h:49691
Definition: hps.h:43400
Definition: hps.h:17815
void NumLock(bool in_state)
Definition: hps.h:48122
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:49768
Control & operator=(Control &&in_that)
Definition: hps.h:6169
Definition: hps.h:50120
Definition: hps.h:32260
Cap
Definition: hps.h:1968
Definition: hps.h:45887
void Right(bool in_state)
Definition: hps.h:48559
HPS::Type ObjectType() const
Definition: hps.h:46721
virtual void Reset()
Definition: hps.h:47354
Definition: hps.h:12985
Definition: hps.h:50658
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:48749
HPS::Type ObjectType() const
Definition: hps.h:31392
std::vector< ByteArray, Allocator< ByteArray > > ByteArrayArray
Array of type HPS::ByteArray.
Definition: hps.h:6861
Definition: hps.h:49467
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4319
std::vector< ShellKey, Allocator< ShellKey > > ShellKeyArray
Array of type HPS::ShellKey.
Definition: hps.h:6906
Type
Definition: hps.h:2187
std::vector< int32_t, Allocator< int32_t > > Int32Array
Array of type int32_t.
Definition: hps.h:6899
Definition: hps.h:40235
TimerTickEvent()
Definition: hps.h:47382
HPS::Type ObjectType() const
Definition: hps.h:41556
Definition: hps.h:44226
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5485
virtual HPS::Type Type() const
Definition: hps.h:21553
Definition: hps.h:42732
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:4096
EmergencyHandler()
Definition: hps.h:46879
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6298
Both cylinder ends will be capped.
TouchID ID
TouchID for this Touch.
Definition: hps.h:6819
static ModifierKeys KeyCapsLock()
Definition: hps.h:48213
Definition: hps.h:41882
HPS::Type ObjectType() const
Definition: hps.h:41714
HPS::Type ObjectType() const
Definition: hps.h:9361
Space
Definition: hps.h:580
Definition: hps.h:51418
Definition: hps.h:6558
Join
Definition: hps.h:1959
Definition: hps.h:27526
Definition: hps.h:7249
HPS::Type ObjectType() const
Definition: hps.h:44122
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:5197
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:5187
Radial bloom.
bool RightAlt() const
Definition: hps.h:48075
virtual HPS::Type Type() const
Definition: hps.h:43201
Control(Control &&in_that)
Definition: hps.h:6164
Definition: hps.h:5920
virtual HPS::Type Type() const
Definition: hps.h:15886
Event * Clone() const
Definition: hps.h:49676
HPS::Type ObjectType() const
Definition: hps.h:42755
Type
Definition: hps.h:2148
bool operator!=(Touch const &in_that) const
Definition: hps.h:6814
HPS::Type ObjectType() const
Definition: hps.h:20413
Definition: hps.h:32128
Definition: hps.h:6376
virtual HPS::Type Type() const
Definition: hps.h:13386
HPS::Type ObjectType() const
Definition: hps.h:41846
Definition: hps.h:42846
Rotation
Definition: hps.h:1665
Definition: hps.h:51939
intptr_t GetClassID() const
Channel
Definition: hps.h:951
HPS::Type ObjectType() const
Definition: hps.h:41472
HPS::Type ObjectType() const
Definition: hps.h:24174
Driver
Definition: hps.h:51695
Definition: hps.h:25128
Action
Definition: hps.h:48348
HPS::Type ObjectType() const
Definition: hps.h:13494
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:48772
Definition: hps.h:43017
Definition: hps.h:50732
std::vector< ReferenceKey, Allocator< ReferenceKey > > ReferenceKeyArray
Array of type HPS::ReferenceKey.
Definition: hps.h:6888
Definition: hps.h:30225
std::vector< GlyphPoint, Allocator< GlyphPoint > > GlyphPointArray
Array of type HPS::GlyphPoint.
Definition: hps.h:6851
Definition: hps.h:2198
Definition: hps.h:7558
std::vector< size_t, Allocator< size_t > > SizeTArray
Array of type size_t.
Definition: hps.h:6844
std::vector< ImageKit, Allocator< ImageKit > > ImageKitArray
Array of type HPS::ImageKit.
Definition: hps.h:6904
HPS::Type ObjectType() const
Definition: hps.h:9593
HPS::Type ObjectType() const
Definition: hps.h:23590
Mode
Definition: hps.h:1900
size_t static_not_flattened_invisible
Number of segments that were not flattened as part of static model generation, because they were invi...
Definition: hps.h:5213