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 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
76 # define OLD_GCC
77 # define OVERRIDE
78 # else
79 # define OVERRIDE override
80 # endif
81 
82 namespace HPSI
83 {
84  class Impl;
85  class KeyImpl;
86  class TicketImpl;
87  class EventDispatcherImpl;
88  class AbstractImage;
89  class String;
90 };
91 
92 namespace HPS
93 {
94 
95  // unimplemented
96 
97 
98 //Begin Info
100 class HPS_API Info
101 {
102 public:
103 
106  enum class Code : uint32_t
107  {
108  Unknown,
109  Exchange,
110  Publish,
111  Data,
112  Key,
113  Geometry,
114  Database,
115  Driver,
116  Internal,
117  Memory,
118  System,
119  Unsupported,
120  DX9DeviceReset,
121  DWG,
122  Parasolid,
123  };
124 
125 private:
126  Info() {}
127 };
128 
129 
130 //Begin Info
132 class HPS_API Emergency
133 {
134 public:
135 
138  enum class Code : uint32_t
139  {
140  Unknown,
141  Fatal,
142  SoftMemoryLimit,
143  HardMemoryLimit,
144  };
145 
146 private:
147  Emergency() {}
148 };
149 
150 
151 //Begin Window
153 class HPS_API Window
154 {
155 public:
156 
161  enum class Driver : uint32_t
162  {
163  Default3D,
164  OpenGL,
165  OpenGL2,
166  DirectX9,
167  DirectX11,
168  };
169 
172  enum class UpdateStatus : uint32_t
173  {
174  InProgress,
175  Completed,
176  TimedOut,
177  Interrupted,
178  Failed
179  };
180 
184  enum class UpdateType : uint32_t
185  {
187  Default,
188 
193  Complete,
194 
196  Refresh,
197 
199  CompileOnly,
200 
204  Exhaustive,
205  };
206 
209  enum class Mobility : uint32_t
210  {
211  Locked,
212  Floating,
213  FixedRatio,
214  Free
215  };
216 
219  enum class FrameSize : uint32_t
220  {
221  Single,
222  Double
223  };
224 
227  enum class FrameOptions : uint32_t
228  {
229  Inset,
230  Overlay
231  };
232 
235  enum class ImageFormat : uint32_t
236  {
237  Default,
238  RGBA,
239  RGB,
240  Jpeg,
241  Png
242  };
243 
244 private:
245  Window() {}
246 };
247 
248 //Begin Subwindow
250 class HPS_API Subwindow
251 {
252 public:
253  enum class Background : uint32_t
254  {
255  SolidColor,
256  Image,
257  Cubemap,
258  Blend,
259  Transparent,
260  Interactive,
261 
262  GradientTopToBottom,
263  GradientBottomToTop,
264  GradientLeftToRight,
265  GradientRightToLeft,
266  GradientTopLeftToBottomRight,
267  GradientTopRightToBottomLeft,
268  GradientBottomLeftToTopRight,
269  GradientBottomRightToTopLeft,
270  };
271 
272  enum class Type : uint32_t
273  {
274  Standard,
275  Lightweight
276  };
277 
278  enum class Border : uint32_t
279  {
280  None,
281  Inset,
282  InsetBold,
283  Overlay,
284  OverlayBold
285  };
286 
287 
289  enum class RenderingAlgorithm : uint32_t
290  {
293  ZBuffer,
294 
300  HiddenLine,
301 
307  FastHiddenLine,
308 
321  Priority
322  };
323 
324 private:
325  Subwindow() {}
326 };
327 //End Subwindow
328 
330 class HPS_API Style
331 {
332 public:
333 
336  enum class Type : uint32_t
337  {
338  Segment,
339  Named
340  };
341 
344  enum class AppendMode : uint32_t
345  {
346  None,
347  And,
348  Or
349  };
350 
351 private:
352  Style() {}
353 };
354 
355 
357 class HPS_API Shell
358 {
359 public:
360 
363  enum class Component : uint32_t
364  {
365  Faces,
366  Edges,
367  Vertices
368  };
369 
370  /* \enum ToleranceUnits
371  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
372  enum class ToleranceUnits : uint32_t
373  {
374  ObjectSpace,
375  FeatureSizePercentage
376  };
377 
378  /* \enum HandednessOptimization
379  * Enumerates the shell optimization options with regards to handedness. */
380  enum class HandednessOptimization : uint32_t
381  {
382  None,
383  Fix,
384  Reverse
385  };
386 
387  /* \enum RelationResults
388  * Enumerates the results of a shell relation computation. */
389  enum class Relation : uint32_t
390  {
391  On,
392  Off,
393  In,
394  Out
395  };
396 
397  /* \enum RelationTest
398  * Enumerates the test options for a shell relation computation. */
399  enum class RelationTest : uint32_t
400  {
401  Simple,
402  Enclosure,
403  Distance
404  };
405 
406 private:
407  Shell() {}
408 };
409 
410 
412 class HPS_API Mesh
413 {
414 public:
415 
418  enum class Component : uint32_t
419  {
420  Faces,
421  Edges,
422  Vertices
423  };
424 
425 private:
426  Mesh() {}
427 };
428 
429 
431 class HPS_API InfiniteLine
432 {
433 public:
434 
437  enum class Type : uint32_t
438  {
439  Line,
440  Ray
441  };
442 
443 private:
444  InfiniteLine() {}
445 };
446 
447 
449 class HPS_API Trim
450 {
451 public:
452 
455  enum class Type : uint32_t
456  {
457  Line,
458  Curve
459  };
460 
464  enum class Operation : uint32_t
465  {
466  Keep,
467  Remove
468  };
469 
470 private:
471  Trim() {}
472 };
473 
474 
476 class HPS_API Spotlight
477 {
478 public:
479 
482  enum class OuterConeUnits : uint32_t
483  {
487  Degrees,
491  FieldRadius
492  };
493 
496  enum class InnerConeUnits : uint32_t
497  {
501  Degrees,
505  FieldRadius,
508  Percent
509  };
510 
511 private:
512  Spotlight() {}
513 };
514 
515 
517 class HPS_API Cylinder
518 {
519 public:
520 
523  enum class Component : uint32_t
524  {
525  Faces,
526  Edges,
527  };
528 
531  enum class Capping : uint32_t
532  {
533  None,
534  First,
535  Last,
536  Both
537  };
538 
541  enum class Orientation : uint32_t
542  {
543  Default,
544  DefaultRadii,
545  InvertRadii,
546  InvertRadiiOnly,
547  DefaultColors,
548  InvertColors,
549  InvertColorsOnly,
550  InvertAll
551  };
552 
553 private:
554  Cylinder() {}
555 };
556 
557 
559 class HPS_API Search
560 {
561 public:
562 
565  enum class Space : uint32_t
566  {
567  SegmentOnly,
568  Subsegments,
569  SubsegmentsAndIncludes
570  };
571 
574  enum class Behavior : uint32_t
575  {
576  Exhaustive,
577  FirstMatch
578  };
579 
582  enum class Type : uint32_t
583  {
584  None = 0x00000000,
585  Everything = 0x00ffffff,
586 
587  Include = 0x00000042,
588  Segment = 0x00000043,
589 
590  Includer = 0x00000100,
591 
592  // Geometry
593  Geometry = 0x10000000,
594 
595  CuttingSection = 0x10000026,
596  Shell = 0x10000028,
597  Mesh = 0x10000029,
598  Grid = 0x1000002a,
599  NURBSSurface = 0x1000002b,
600  Cylinder = 0x1000002d,
601  Sphere = 0x1000002e,
602  Polygon = 0x1000002f,
603  Circle = 0x10000030,
604  //unused = 0x10000031,
605  CircularWedge = 0x10000032,
606  Ellipse = 0x10000033,
607  Line = 0x10000034,
608  NURBSCurve = 0x10000037,
609  CircularArc = 0x10000038,
610  EllipticalArc = 0x10000039,
611  InfiniteLine = 0x1000003a,
612  //unused = 0x1000003b,
613  Marker = 0x1000003c,
614  Text = 0x1000003e,
615  Reference = 0x10000041,
616 
617  DistantLight = 0x10000100,
618  Spotlight = 0x10000101,
619  InfiniteRay = 0x10000102,
620 
621  // Attributes
622  Attribute = 0x20000000,
623 
624  Priority = 0x20000001,
625 
626  // Simple Attributes
627  Material = 0x2000000b,
628  Camera = 0x2000000f,
629  ModellingMatrix = 0x20000011,
630  UserData = 0x20000022,
631  TextureMatrix = 0x20000024,
632 
633  // Complex Attributes
634  Culling = 0x20001000,
635  CullingBackFace = 0x20001001,
636  CullingExtent = 0x20001002,
637  CullingVector = 0x20001003,
638  CullingVectorTolerance = 0x20001004,
639  CullingFrustum = 0x20001005,
640  CullingDeferralExtent = 0x20001006,
641 
642  CurveAttribute = 0x20002000,
643  CurveAttributeBudget = 0x20002001,
644  CurveAttributeContinuedBudget = 0x20002002,
645  CurveAttributeViewDependent = 0x20002003,
646  CurveAttributeMaximumDeviation = 0x20002004,
647  CurveAttributeMaximumAngle = 0x20002005,
648  CurveAttributeMaximumLength = 0x20002006,
649 
650  CylinderAttribute = 0x20003000,
651  CylinderAttributeTessellation = 0x20003001,
652  CylinderAttributeOrientation = 0x20003002,
653 
654  EdgeAttribute = 0x20004000,
655  EdgeAttributePattern = 0x20004016,
656  EdgeAttributeWeight = 0x20004017,
657  EdgeAttributeHardAngle = 0x20004018,
658 
659  LightingAttribute = 0x20005000,
660  LightingAttributeInterpolation = 0x20005001,
661 
662  LineAttribute = 0x20006000,
663  LineAttributePattern = 0x2000601a,
664  LineAttributeWeight = 0x2000601b,
665 
666  MarkerAttribute = 0x20007000,
667  MarkerAttributeSize = 0x2000701c,
668  MarkerAttributeSymbol = 0x2000701d,
669 
670  SurfaceAttribute = 0x20008000,
671  SurfaceAttributeBudget = 0x20008001,
672  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
673  SurfaceAttributeMaximumFacetAngle = 0x20008003,
674  SurfaceAttributeMaximumFacetWidth = 0x20008004,
675  SurfaceAttributeTrimCurveBudget = 0x20008005,
676  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
677 
678  Selectability = 0x20009000,
679  SelectabilityWindows = 0x20009001,
680  SelectabilityEdges = 0x20009002,
681  SelectabilityFaces = 0x20009003,
682  SelectabilityLights = 0x20009004,
683  SelectabilityLines = 0x20009005,
684  SelectabilityMarkers = 0x20009006,
685  SelectabilityVertices = 0x20009007,
686  SelectabilityText = 0x20009008,
687 
688  SphereAttribute = 0x2000a000,
689  SphereAttributeTessellation = 0x2000a001,
690 
691  Subwindow = 0x2000b000,
692  SubwindowEitherType = 0x2000b001,
693  SubwindowStandard = 0x2000b00e,
694  SubwindowLightweight = 0x2000b002,
695  SubwindowBackground = 0x2000b003,
696  SubwindowBorder = 0x2000b004,
697  SubwindowRenderingAlgorithm = 0x2000b005,
698 
699  TextAttribute = 0x2000c000,
700  TextAttributeAlignment = 0x2000c01e,
701  TextAttributeBold = 0x2000c002,
702  TextAttributeItalic = 0x2000c003,
703  TextAttributeOverline = 0x2000c004,
704  TextAttributeStrikethrough = 0x2000c005,
705  TextAttributeUnderline = 0x2000c006,
706  TextAttributeSlant = 0x2000c007,
707  TextAttributeLineSpacing = 0x2000c008,
708  TextAttributeRotation = 0x2000c00a,
709  TextAttributeExtraSpace = 0x2000c00b,
710  TextAttributeGreeking = 0x2000c00c,
711  TextAttributeSizeTolerance = 0x2000c00d,
712  TextAttributeSize = 0x2000c00e,
713  TextAttributeFont = 0x2000c00f,
714  TextAttributeTransform = 0x2000c010,
715  TextAttributeRenderer = 0x2000c011,
716  TextAttributePreference = 0x2000c012,
717  TextAttributePath = 0x2000c020,
718  TextAttributeSpacing = 0x2000c021,
719  TextAttributeBackground = 0x2000c022,
720  TextAttributeBackgroundMargins = 0x2000c023,
721  TextAttributeBackgroundStyle = 0x2000c024,
722  TextAttributeLeaderLine = 0x2000c025,
723 
724  Transparency = 0x2000d000,
725  TransparencyMethod = 0x2000d001,
726  TransparencyAlgorithm = 0x2000d002,
727  TransparencyDepthPeelingLayers = 0x2000d004,
728  TransparencyDepthPeelingMinimumArea = 0x2000d005,
729  TransparencyDepthWriting = 0x2000d006,
730 
731  Visibility = 0x2000e000,
732  VisibilityCuttingSections = 0x2000e001,
733  VisibilityCutEdges = 0x2000e002,
734  VisibilityCutFaces = 0x2000e003,
735  VisibilityWindows = 0x2000e004,
736  VisibilityText = 0x2000e005,
737  VisibilityLines = 0x2000e006,
738  VisibilityEdgeLights = 0x2000e007,
739  VisibilityMarkerLights = 0x2000e008,
740  VisibilityFaceLights = 0x2000e009,
741  VisibilityGenericEdges = 0x2000e00a,
742  VisibilityHardEdges = 0x2000e00b,
743  VisibilityAdjacentEdges = 0x2000e00c,
744  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
745  VisibilityShadowEmitting = 0x2000e00e,
746  VisibilityShadowReceiving = 0x2000e00f,
747  VisibilityShadowCasting = 0x2000e010,
748  VisibilityMarkers = 0x2000e011,
749  VisibilityVertices = 0x2000e012,
750  VisibilityFaces = 0x2000e013,
751  VisibilityPerimeterEdges = 0x2000e014,
752  VisibilityNonCulledEdges = 0x2000e015,
753  VisibilityMeshQuadEdges = 0x2000e016,
754  VisibilityEdges = 0x2000e017,
755  VisibilityLeaderLines = 0x2000e018,
756 
757  VisualEffects = 0x2000f000,
758  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
759  VisualEffectsAntiAliasing = 0x2000f002,
760  VisualEffectsShadowMaps = 0x2000f003,
761  VisualEffectsSimpleShadow = 0x2000f004,
762  VisualEffectsSimpleShadowPlane = 0x2000f005,
763  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
764  VisualEffectsSimpleShadowColor = 0x2000f007,
765  VisualEffectsSimpleReflection = 0x2000f008,
766  VisualEffectsSimpleReflectionPlane = 0x2000f009,
767  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
768  VisualEffectsEyeDomeLightingBackColor = 0x2000f00b,
769 
770  Performance = 0x20010000,
771  PerformanceDisplayLists = 0x20010001,
772  PerformanceStaticModel = 0x20010002,
773  StaticModelSegment = 0x40000043,
774 
775  DrawingAttribute = 0x20011000,
776  DrawingAttributePolygonHandedness = 0x20011001,
777  DrawingAttributeDepthRange = 0x20011002,
778  DrawingAttributeFaceDisplacement = 0x20011003,
779  DrawingAttributeGeneralDisplacement = 0x20011004,
780  DrawingAttributeVertexDisplacement = 0x20011005,
781  DrawingAttributeOverlay = 0x20011006,
782  DrawingAttributeDeferral = 0x20011007,
783  DrawingAttributeVertexDecimation = 0x20011008,
784  DrawingAttributeVertexRandomization = 0x20011009,
785  DrawingAttributeClipRegion = 0x20011013,
786  DrawingAttributeWorldHandedness = 0x20011019,
787 
788  HiddenLineAttribute = 0x20012000,
789  HiddenLineAttributeColor = 0x20012001,
790  HiddenLineAttributeDimFactor = 0x20012002,
791  HiddenLineAttributeFaceDisplacement = 0x20012003,
792  HiddenLineAttributeLinePattern = 0x20012005,
793  HiddenLineAttributeRenderFaces = 0x20012006,
794  HiddenLineAttributeRenderText = 0x20012007,
795  HiddenLineAttributeAlgorithm = 0x20012008,
796  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
797  HiddenLineAttributeVisibility = 0x2001200a,
798  HiddenLineAttributeWeight = 0x2001200b,
799  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
800 
801  SegmentStyle = 0x20013001,
802  NamedStyle = 0x20013002,
803  MaterialPalette = 0x20013003,
804  Portfolio = 0x20013004,
805 
806  ContourLine = 0x20014000,
807  ContourLineVisibility = 0x20014001,
808  ContourLinePosition = 0x20014002,
809  ContourLineColor = 0x20014003,
810  ContourLinePattern = 0x20014004,
811  ContourLineWeight = 0x20014005,
812  ContourLineLighting = 0x20014006,
813 
814  Condition = 0x20015000,
815 
816  Bounding = 0x20016000,
817  BoundingVolume = 0x20016001,
818  BoundingExclusion = 0x20016002,
819 
820  AttributeLock = 0x20017000,
821  AttributeLockSetting = 0x20017001,
822  AttributeLockSubsegmentOverride = 0x20017002,
823 
824  TransformMask = 0x20018000,
825  TransformMaskCamera = 0x20018001,
826  TransformMaskCameraTranslation = 0x20018002,
827  TransformMaskCameraScale = 0x20018003,
828  TransformMaskCameraOffset = 0x20018004,
829  TransformMaskCameraRotation = 0x20018005,
830  TransformMaskCameraPerspectiveScale = 0x20018006,
831  TransformMaskCameraProjection = 0x20018007,
832  TransformMaskModellingMatrix = 0x20018008,
833  TransformMaskModellingMatrixTranslation = 0x20018009,
834  TransformMaskModellingMatrixScale = 0x20018010,
835  TransformMaskModellingMatrixOffset = 0x20018011,
836  TransformMaskModellingMatrixRotation = 0x20018012,
837 
838  ColorInterpolation = 0x20019000,
839  ColorInterpolationFaceColor = 0x20019001,
840  ColorInterpolationEdgeColor = 0x20019002,
841  ColorInterpolationMarkerColor = 0x20019003,
842  ColorInterpolationFaceIndex = 0x20019004,
843  ColorInterpolationEdgeIndex = 0x20019005,
844  ColorInterpolationMarkerIndex = 0x20019006,
845 
846  CuttingSectionAttribute = 0x2001a000,
847  CuttingSectionAttributeCuttingLevel = 0x2001a001,
848  CuttingSectionAttributeCappingLevel = 0x2001a002,
849  CuttingSectionAttributeMaterialPreference = 0x2001a003,
850  CuttingSectionAttributeEdgeWeight = 0x2001a004,
851  CuttingSectionAttributeTolerance = 0x2001a005,
852 
853  };
854 
855 private:
856  Search() {}
857 };
858 
859 
861 class HPS_API Material
862 {
863 public:
864 
867  enum class Type : uint32_t
868  {
869  None = 0,
870  FullMaterial,
871  RGBColor,
872  RGBAColor,
873  MaterialIndex,
874  TextureName,
875  ModulatedTexture,
876  CubeMapName,
877  ModulatedCubeMap,
878  GlossValue,
879  DiffuseChannelAlpha
880  };
881 
884  enum class Channel : uint32_t
885  {
886  DiffuseColor = 1,
887  DiffuseTexture = 2,
888  Specular = 3,
889  Emission = 4,
890  Transmission = 5,
891  Mirror = 6,
892  Bump = 7,
893  EnvironmentTexture = 8,
894  EnvironmentCubeMap = 9,
895  Gloss = 10
896  };
897 
899  class HPS_API Color
900  {
901  public:
902 
905  enum class Channel : uint32_t
906  {
907  DiffuseColor = 1,
908  Specular = 3,
909  Emission = 4,
910  Mirror = 6
911  };
912 
913  private:
914  Color() {}
915  };
916 
918  class HPS_API Texture
919  {
920  public:
921 
924  enum class Channel : uint32_t
925  {
926  DiffuseTexture = 2,
927  Specular = 3,
928  Emission = 4,
929  Transmission = 5,
930  Mirror = 6,
931  Bump = 7,
932  EnvironmentTexture = 8,
933  EnvironmentCubeMap = 9
934  };
935 
938  enum class Parameterization : uint32_t
939  {
941  Cylinder,
942 
944  PhysicalReflection,
945 
947  Object,
948 
954  NaturalUV,
955 
957  ReflectionVector,
958 
960  SurfaceNormal,
961 
963  Sphere,
964 
966  UV,
967 
969  World
970  };
971 
974  enum class Tiling : uint32_t
975  {
978  Clamp,
979 
981  Repeat,
982 
984  Reflect,
985 
988  Trim
989  };
990 
993  enum class Interpolation : uint32_t
994  {
996  None,
997 
999  Bilinear
1000  };
1001 
1004  enum class Decimation : uint32_t
1005  {
1007  None,
1008 
1011  Anisotropic,
1012 
1014  Mipmap
1015  };
1016 
1020  enum class ChannelMapping : uint32_t
1021  {
1022  Red,
1023  Green,
1024  Blue,
1025  Alpha,
1026  Zero,
1027  One,
1028  Luminance
1029  };
1030 
1031  private:
1032  Texture() {}
1033  };
1034 
1035 private:
1036  Material() {}
1037 };
1038 
1039 
1040 class HPS_API PostProcessEffects
1041 {
1042 public:
1043 
1044  class HPS_API AmbientOcclusion
1045  {
1046  public:
1047 
1050  enum class Quality : uint32_t
1051  {
1052  Fastest,
1053  Nicest
1054  };
1055 
1056  private:
1057  AmbientOcclusion() {}
1058  };
1059 
1060  class HPS_API Bloom
1061  {
1062  public:
1066  enum class Shape : uint32_t
1067  {
1068  Star,
1069  Radial
1070  };
1071 
1072  private:
1073  Bloom() {}
1074  };
1075 
1076 private:
1077  PostProcessEffects() {}
1078 };
1079 
1080 class HPS_API Performance
1081 {
1082 public:
1083 
1087  enum class DisplayLists : uint32_t
1088  {
1090  None,
1091 
1094  Geometry,
1095 
1098  Segment
1099  };
1100 
1109  enum class StaticModel : uint32_t
1110  {
1111 
1112  None,
1113  Attribute,
1114  AttributeSpatial
1115  };
1116 
1117 
1118 private:
1119  Performance() {}
1120 };
1121 
1122 
1123 class HPS_API AttributeLock
1124 {
1125 public:
1126 
1128  enum class Type : uint32_t
1129  {
1130  Everything = 0x01000000,
1131 
1132  Visibility = 0x02000000,
1133 
1134  VisibilityCuttingSections,
1135  VisibilityCutEdges,
1136  VisibilityCutFaces,
1137  VisibilityWindows,
1138  VisibilityText,
1139  VisibilityLines,
1140  VisibilityEdgeLights,
1141  VisibilityMarkerLights,
1142  VisibilityFaceLights,
1143  VisibilityGenericEdges,
1144  VisibilityHardEdges,
1145  VisibilityAdjacentEdges,
1146  VisibilityInteriorSilhouetteEdges,
1147  VisibilityShadowEmitting,
1148  VisibilityShadowReceiving,
1149  VisibilityShadowCasting,
1150  VisibilityMarkers,
1151  VisibilityVertices,
1152  VisibilityFaces,
1153  VisibilityPerimeterEdges,
1154  VisibilityNonCulledEdges,
1155  VisibilityMeshQuadEdges,
1156  VisibilityCutGeometry,
1157  VisibilityEdges,
1158  VisibilityGeometry,
1159  VisibilityLights,
1160  VisibilityShadows,
1161 
1162  Material = 0x03000000,
1163 
1164  MaterialGeometry,
1165  MaterialCutGeometry,
1166 
1167  MaterialAmbientLightUpColor,
1168  MaterialAmbientLightDownColor,
1169  MaterialAmbientLightColor,
1170 
1171  MaterialWindowColor,
1172  MaterialWindowContrastColor,
1173 
1174  MaterialLightColor,
1175  MaterialLineColor,
1176  MaterialMarkerColor,
1177  MaterialTextColor,
1178  MaterialCutEdgeColor,
1179 
1180  MaterialVertex,
1181  MaterialVertexDiffuse,
1182  MaterialVertexDiffuseColor,
1183  MaterialVertexDiffuseAlpha,
1184  MaterialVertexDiffuseTexture,
1185  MaterialVertexSpecular,
1186  MaterialVertexMirror,
1187  MaterialVertexTransmission,
1188  MaterialVertexEmission,
1189  MaterialVertexEnvironment,
1190  MaterialVertexBump,
1191  MaterialVertexGloss,
1192 
1193  MaterialEdge,
1194  MaterialEdgeDiffuse,
1195  MaterialEdgeDiffuseColor,
1196  MaterialEdgeDiffuseAlpha,
1197  MaterialEdgeDiffuseTexture,
1198  MaterialEdgeSpecular,
1199  MaterialEdgeMirror,
1200  MaterialEdgeTransmission,
1201  MaterialEdgeEmission,
1202  MaterialEdgeEnvironment,
1203  MaterialEdgeBump,
1204  MaterialEdgeGloss,
1205 
1206  MaterialFace,
1207  MaterialFaceDiffuse,
1208  MaterialFaceDiffuseColor,
1209  MaterialFaceDiffuseAlpha,
1210  MaterialFaceDiffuseTexture,
1211  MaterialFaceSpecular,
1212  MaterialFaceMirror,
1213  MaterialFaceTransmission,
1214  MaterialFaceEmission,
1215  MaterialFaceEnvironment,
1216  MaterialFaceBump,
1217  MaterialFaceGloss,
1218 
1219  MaterialBackFace,
1220  MaterialBackFaceDiffuse,
1221  MaterialBackFaceDiffuseColor,
1222  MaterialBackFaceDiffuseAlpha,
1223  MaterialBackFaceDiffuseTexture,
1224  MaterialBackFaceSpecular,
1225  MaterialBackFaceMirror,
1226  MaterialBackFaceTransmission,
1227  MaterialBackFaceEmission,
1228  MaterialBackFaceEnvironment,
1229  MaterialBackFaceBump,
1230  MaterialBackFaceGloss,
1231 
1232  MaterialFrontFace,
1233  MaterialFrontFaceDiffuse,
1234  MaterialFrontFaceDiffuseColor,
1235  MaterialFrontFaceDiffuseAlpha,
1236  MaterialFrontFaceDiffuseTexture,
1237  MaterialFrontFaceSpecular,
1238  MaterialFrontFaceMirror,
1239  MaterialFrontFaceTransmission,
1240  MaterialFrontFaceEmission,
1241  MaterialFrontFaceEnvironment,
1242  MaterialFrontFaceBump,
1243  MaterialFrontFaceGloss,
1244 
1245  MaterialCutFace,
1246  MaterialCutFaceDiffuse,
1247  MaterialCutFaceDiffuseColor,
1248  MaterialCutFaceDiffuseAlpha,
1249  MaterialCutFaceDiffuseTexture,
1250  MaterialCutFaceSpecular,
1251  MaterialCutFaceMirror,
1252  MaterialCutFaceTransmission,
1253  MaterialCutFaceEmission,
1254  MaterialCutFaceEnvironment,
1255  MaterialCutFaceBump,
1256  MaterialCutFaceGloss,
1257 
1258  Camera = 0x04000000,
1259  };
1260 
1261 private:
1262  AttributeLock() {}
1263 };
1264 
1265 class HPS_API Drawing
1266 {
1267 public:
1268 
1271  enum class Handedness : uint32_t
1272  {
1273  None,
1274  Left,
1275  Right
1276  };
1277 
1280  enum class Overlay : uint32_t
1281  {
1283  None,
1284 
1287  Default,
1288 
1291  WithZValues,
1292 
1297  InPlace,
1298  };
1299 
1302  enum class ClipOperation : uint32_t
1303  {
1304  Keep,
1305  Remove,
1306  };
1307 
1310  enum class ClipSpace : uint32_t
1311  {
1312  Window,
1313  World,
1314  Object,
1315  };
1316 
1317 private:
1318  Drawing() {}
1319 };
1320 
1321 
1322 class HPS_API HiddenLine
1323 {
1324 public:
1325 
1329  enum class Algorithm : uint32_t
1330  {
1331  None,
1332  ZBuffer,
1333  ZSort,
1334  };
1335 
1336 private:
1337  HiddenLine() {}
1338 };
1339 
1340 
1342 class HPS_API Selection
1343 {
1344 public:
1345 
1348  enum class Level : uint32_t
1349  {
1350  Segment,
1351  Entity,
1352  Subentity,
1353  };
1354 
1357  enum class Algorithm : uint32_t
1358  {
1363  Visual,
1364 
1369  Analytic
1370  };
1371 
1374  enum class Granularity : uint32_t
1375  {
1376  General,
1377  Detailed
1378  };
1379 
1380 private:
1381  Selection() {}
1382 };
1383 
1384 
1388 
1390 class HPS_API Camera
1391 {
1392 public:
1393 
1396  enum class Projection : uint32_t
1397  {
1398  Default = 1 ,
1399  Perspective,
1400  Orthographic,
1401  Stretched,
1402  };
1403 
1404 private:
1405  Camera() {}
1406 };
1407 
1408 
1410 class HPS_API Selectability
1411 {
1412 public:
1416  enum class Value : uint32_t
1417  {
1418  Off = 0,
1419  On,
1420  ForcedOn
1421  };
1422 
1423 private:
1424  Selectability() {}
1425 };
1426 
1427 
1429 class HPS_API Transparency
1430 {
1431 public:
1432 
1435  enum class Method : uint32_t
1436  {
1437  None,
1438  Blended,
1439  ScreenDoor
1440  };
1441 
1444  enum class Algorithm : uint32_t
1445  {
1446  None,
1447  Painters,
1448  ZSortNicest,
1449  ZSortFastest,
1450  DepthPeeling,
1451  WeightedBlended
1452  };
1453 
1457  enum class AreaUnits : uint32_t
1458  {
1459  Percent,
1460  Pixels
1461  };
1462 
1466  enum class Preference
1467  {
1468  Nicest,
1469  Fastest,
1470  };
1471 
1472 private:
1473  Transparency() {}
1474 };
1475 
1476 
1478 class HPS_API Marker
1479 {
1480 public:
1481 
1484  enum class SizeUnits : uint32_t
1485  {
1486  ScaleFactor,
1487  ObjectSpace,
1488  SubscreenRelative,
1489  WindowRelative,
1490  WorldSpace,
1491  Points,
1492  Pixels
1493  };
1494 
1495 private:
1496  Marker() {}
1497 };
1498 
1499 
1501 class HPS_API Lighting
1502 {
1503 public:
1504 
1507  enum class InterpolationAlgorithm : uint32_t
1508  {
1509  Phong,
1510  Gouraud,
1511  Flat
1512  };
1513 
1514 private:
1515  Lighting() {}
1516 };
1517 
1519 class HPS_API Text
1520 {
1521 public:
1522 
1525  enum class Alignment : uint32_t
1526  {
1527  TopLeft,
1528  CenterLeft,
1529  BottomLeft,
1530  TopCenter,
1531  Center,
1532  BottomCenter,
1533  TopRight,
1534  CenterRight,
1535  BottomRight
1536  };
1537 
1540  enum class ReferenceFrame : uint32_t
1541  {
1542  WorldAligned,
1543  PathAligned
1544  };
1545 
1548  enum class Justification : uint32_t
1549  {
1550  Left,
1551  Right,
1552  Center
1553  };
1554 
1557  enum class Transform : uint32_t
1558  {
1560  Transformable,
1563  NonTransformable,
1565  CharacterPositionOnly,
1568  CharacterPositionAdjusted,
1570  NonScalingTransformable
1571  };
1572 
1575  enum class Renderer : uint32_t
1576  {
1577  Default,
1578  Driver,
1579  Truetype,
1580  };
1581 
1584  enum class Preference : uint32_t
1585  {
1586  Default,
1587  Vector,
1588  Raster,
1589  Exterior
1590  };
1591 
1594  enum class Rotation : uint32_t
1595  {
1596  None,
1597  Rotate,
1598  FollowPath
1599  };
1600 
1601 
1604  enum class SizeUnits : uint32_t
1605  {
1606  ObjectSpace,
1607  SubscreenRelative,
1608  WindowRelative,
1609  WorldSpace,
1610  Points,
1611  Pixels
1612  };
1613 
1616  enum class SizeToleranceUnits : uint32_t
1617  {
1618  ObjectSpace,
1619  SubscreenRelative,
1620  WindowRelative,
1621  WorldSpace,
1622  Points,
1623  Pixels,
1624  Percent
1625  };
1626 
1629  enum class MarginUnits : uint32_t
1630  {
1631  ObjectSpace,
1632  SubscreenRelative,
1633  WindowRelative,
1634  WorldSpace,
1635  Points,
1636  Pixels,
1637  Percent
1638  };
1639 
1642  enum class GreekingUnits : uint32_t
1643  {
1644  ObjectSpace,
1645  SubscreenRelative,
1646  WindowRelative,
1647  WorldSpace,
1648  Points,
1649  Pixels
1650  };
1651 
1654  enum class GreekingMode : uint32_t
1655  {
1656  Nothing,
1657  Lines,
1658  Box
1659  };
1660 
1663  enum class RegionAlignment : uint32_t
1664  {
1665  Top,
1666  Center,
1667  Bottom
1668  };
1669 
1672  enum class LeaderLineSpace : uint32_t
1673  {
1674  Object,
1675  World,
1676  };
1677 private:
1678  Text() {}
1679 };
1680 
1681 
1683 class HPS_API Line
1684 {
1685 public:
1686 
1690  enum class SizeUnits : uint32_t
1691  {
1692  ScaleFactor,
1693  ObjectSpace,
1694  SubscreenRelative,
1695  WindowRelative,
1696  WorldSpace,
1697  Points,
1698  Pixels
1699  };
1700 
1701 private:
1702  Line() {}
1703 };
1704 
1705 
1707 class HPS_API Edge
1708 {
1709 public:
1710 
1713  enum class SizeUnits : uint32_t
1714  {
1715  ScaleFactor,
1716  ObjectSpace,
1717  SubscreenRelative,
1718  WindowRelative,
1719  WorldSpace,
1720  Points,
1721  Pixels
1722  };
1723 
1724 private:
1725  Edge() {}
1726 };
1727 
1728 
1730 class HPS_API CuttingSection
1731 {
1732 public:
1733 
1736  enum class Mode : uint32_t
1737  {
1738  None,
1739  Round,
1740  Square,
1741  Plane
1742  };
1743 
1746  enum class CappingLevel : uint32_t
1747  {
1748  Entity,
1749  Segment,
1750  SegmentTree
1751  };
1752 
1755  enum class ToleranceUnits : uint32_t
1756  {
1757  Percent,
1758  WorldSpace,
1759  };
1760 
1763  enum class CuttingLevel : uint32_t
1764  {
1765  Global,
1766  Local,
1767  };
1768 
1771  enum class MaterialPreference : uint32_t
1772  {
1773  Explicit,
1774  Implicit,
1775  };
1776 
1779  enum class GatheringLevel : uint32_t
1780  {
1781  Segment,
1782  SegmentTree
1783  };
1784 
1785 private:
1786  CuttingSection() {}
1787 };
1788 
1790 class HPS_API ContourLine
1791 {
1792 public:
1793 
1797  enum class Mode : uint32_t
1798  {
1799  Repeating,
1800  Explicit,
1801  };
1802 
1803 private:
1804  ContourLine() {}
1805 };
1806 
1809 enum class IOResult : uint32_t
1810 {
1811  Success,
1812  Failure,
1813  FileNotFound,
1814  UnableToOpenFile,
1815  InvalidOptions,
1816  InvalidSegment,
1817  InProgress,
1818  Canceled,
1819  UnableToLoadLibraries,
1820  VersionIncompatibility,
1821  InitializationFailed,
1822  UnsupportedFormat,
1823  InvalidFile,
1824 };
1825 
1827 class HPS_API LinePattern
1828 {
1829 public:
1830 
1833  enum class SizeUnits : uint32_t
1834  {
1835  ObjectSpace,
1836  SubscreenRelative,
1837  WindowRelative,
1838  WorldSpace,
1839  Points,
1840  Pixels,
1841  ScaleFactor
1842  };
1843 
1846  enum class InsetBehavior : uint32_t
1847  {
1848  Overlap,
1849  Trim,
1850  Inline
1851  };
1852 
1856  enum class Join : uint32_t
1857  {
1858  Mitre,
1859  Round,
1860  Bevel
1861  };
1862 
1865  enum class Cap : uint32_t
1866  {
1869  Butt,
1872  Square,
1875  Round,
1877  Mitre
1878  };
1879 
1882  enum class Justification : uint32_t
1883  {
1886  Center,
1888  Stretch
1889  };
1890 
1893  enum class Modifier : uint32_t
1894  {
1895  GlyphName,
1896  Enumerated
1897  };
1898 
1899 
1913  enum class Default : uint32_t
1914  {
1915  Solid,
1916  DashDot,
1917  Dashed,
1918  Dotted,
1919  Dash2Dot,
1920  Dash3Dot,
1921  LongDash,
1922  LongDashShortDash,
1923  LongDash2ShortDash,
1924  FineDot,
1925  };
1926 
1927 private:
1928  LinePattern() {}
1929 };
1930 
1931 
1933 class HPS_API Shape
1934 {
1935 public:
1936  enum class Default : uint32_t
1937  {
1938  Rectangle,
1939  RoundedRectangle,
1940  Oval,
1941  Ellipse,
1942  };
1943 
1944 private:
1945  Shape() {}
1946 };
1947 
1948 
1949 //Begin Glyphs
1951 class HPS_API Glyph
1952 {
1953 public:
1954 
1957  enum class Fill : uint32_t
1958  {
1959  None,
1960  Continuous,
1961  New
1962  };
1963 
1966  enum class ColorSource : uint32_t
1967  {
1968  Default,
1969  Explicit,
1970  Indexed
1971  };
1972 
1976  enum class Default : uint32_t
1977  {
1978  Circle,
1979  CircleWithDot,
1980  CircleWithPlus,
1981  CircleWithTimes,
1982  CircleWithCircle,
1983  SolidCircle,
1984  Dot,
1985  Plus,
1986  Times,
1987  Splat,
1988  Box,
1989  BoxWithDot,
1990  BoxWithTimes,
1991  SolidBox,
1992  Diamond,
1993  DiamondWithDot,
1994  DiamondWithPlus,
1995  SolidDiamond,
1996  TriangleUp,
1997  TriangleUpWithDot,
1998  SolidTriangleUp,
1999  TriangleDown,
2000  TriangleDownWithDot,
2001  SolidTriangleDown,
2002  TriangleRight,
2003  TriangleRightWithDot,
2004  SolidTriangleRight,
2005  TriangleLeft,
2006  TriangleLeftWithDot,
2007  SolidTriangleLeft,
2008  TriangleUpV,
2009  SolidTriangleUpV,
2010  TriangleDownV,
2011  SolidTriangleDownV,
2012  TriangleRightV,
2013  SolidTriangleRightV,
2014  TriangleLeftV,
2015  SolidTriangleLeftV,
2016  LetterY,
2017  LetterZ,
2018  CircleLetterY,
2019  CircleLetterZ,
2020  VerticalBar,
2021  HorizontalBar,
2022  SlantLeft,
2023  SlantRight,
2024  WidePlus,
2025  SolidWidePlus,
2026  WideTimes,
2027  SolidWideTimes,
2028  Pound,
2029  Sphere,
2030  };
2031 
2032 private:
2033  Glyph() {}
2034 };
2035 
2036 
2038 class HPS_API Bounding
2039 {
2040 public:
2041 
2044  enum class Type : uint32_t
2045  {
2046  None,
2047  Sphere,
2048  Cuboid
2049  };
2050 
2051 private:
2052  Bounding() {}
2053 };
2054 
2055 
2057 class HPS_API Condition
2058 {
2059 public:
2060 
2061  enum class Intrinsic : uint32_t
2062  {
2063  Extent,
2064  DrawPass,
2065  InnerPixelWidth,
2066  InnerPixelHeight,
2067  Selection,
2068  QuickMovesProbe,
2069  };
2070 
2071 private:
2072  Condition() {}
2073 };
2074 
2075 
2077 class HPS_API Grid
2078 {
2079 public:
2080 
2083  enum class Type : uint32_t
2084  {
2085  Quadrilateral,
2086  Radial
2087  };
2088 
2089 private:
2090  Grid() {}
2091 };
2092 
2093 
2095 {
2096 public:
2097 
2098  enum class UserData : uint32_t
2099  {
2100  None,
2101  Discard,
2102  Preserve,
2103  Merge,
2104  Localize,
2105  };
2106 
2107  enum class Scope : uint32_t
2108  {
2109  SubSegments,
2110  SubsegmentsAndIncludes,
2111  };
2112 
2113  enum class Expansion : uint32_t
2114  {
2115  None,
2116  Includes,
2117  References,
2118  IncludesAndReferences,
2119  };
2120 
2121  enum class Matrix : uint32_t
2122  {
2123  None,
2124  Localize,
2125  Collapse,
2126  };
2127 
2128  enum class Reorganization : uint32_t
2129  {
2130  None,
2131  Attribute,
2132  Spatial,
2133  AttributeSpatial,
2134  };
2135 
2136 private:
2138 };
2139 
2140 
2142 class HPS_API Coordinate
2143 {
2144 public:
2145 
2149  enum class Space : uint32_t
2150  {
2151  Object,
2152  World,
2153  Camera,
2154  Normalized,
2155  ScreenRange,
2156  InnerWindow,
2157  InnerPixel,
2158  Window,
2159  Pixel,
2160  NormalizedInnerWindow,
2161  NormalizedInnerPixel,
2162  NormalizedWindow,
2163  NormalizedPixel,
2164  };
2165 
2166 private:
2167  Coordinate() {}
2168 };
2169 
2170 
2172 class HPS_API Extent
2173 {
2174 public:
2175 
2176  enum class ClipRegion : uint32_t
2177  {
2178  Include,
2179  Ignore
2180  };
2181 
2182 private:
2183  Extent() {}
2184 };
2185 
2186  typedef double Time;
2187 
2188 #ifdef _MSC_VER
2189 # ifndef HPS_INLINE
2190 # define HPS_INLINE __forceinline
2191 # endif
2192 #else
2193 # define HPS_INLINE inline
2194 #endif
2195 
2196 #ifndef HPS_UNREFERENCED
2197 #define HPS_UNREFERENCED(param) ((void)(param))
2198 #endif
2199 
2200 
2201 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2202 
2203 template<typename T>
2204 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2205 {
2206  return degrees * (T)(PI / 180.0);
2207 }
2208 
2209 template<typename T>
2210 HPS_INLINE T Radians_To_Degrees(T const & radians)
2211 {
2212  return radians * (T)(180.0 / PI);
2213 }
2214 
2215 template<typename T>
2216 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2217  T a = Degrees_To_Radians(angle);
2218  cosine = cos(a);
2219  sine = sin(a);
2220 }
2221 
2222 template<typename T>
2223 HPS_INLINE T Cos(T const & angle) {
2224  return cos (Degrees_To_Radians(angle));
2225 }
2226 
2227 template<typename T>
2228 HPS_INLINE T Sin(T const & angle) {
2229  return sin (Degrees_To_Radians(angle));
2230 }
2231 
2232 template<typename T>
2233 HPS_INLINE T ACos(T const & x) {
2234  if (x > 1)
2235  return 0;
2236  if (x < -1)
2237  return 180;
2238  return Radians_To_Degrees(acos(x));
2239 }
2240 
2241 template<typename T>
2242 HPS_INLINE T ATan2(T const & y, T const & x) {
2243  if (x == 0 && y == 0)
2244  return 0;
2245  return Radians_To_Degrees(atan2(y, x));
2246 }
2247 
2248 
2249 template <typename F> struct Float_Traits {};
2250 template <> struct Float_Traits<float> {
2251  typedef double Alternative;
2252  static const int Type = 1;
2253  static float Epsilon () { return 1.0e-30f; }
2254 };
2255 template <> struct Float_Traits<double> {
2256  typedef float Alternative;
2257  static const int Type = 2;
2258  static double Epsilon () { return 1.0e-300; }
2259 };
2260 
2261 
2262 
2264 class HPS_API Float {
2265 private:
2266  enum Parts {
2267 # if HOOPS_BIGENDIAN
2268  High, Low
2269 # else
2270  Low, High
2271 # endif
2272  };
2273 
2274  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2275  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2276  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2277  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2278  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2279 
2280  static HPS_INLINE bool is_nan(int32_t const & v) {
2281  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2282  return exp == 0x7F800000 && mantissa != 0;
2283  }
2284  static HPS_INLINE bool is_nan(uint32_t const & v) {
2285  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2286  return exp == 0x7F800000 && mantissa != 0;
2287  }
2288  static HPS_INLINE bool is_nan(int32_t const * v) {
2289  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2290  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2291  }
2292  static HPS_INLINE bool is_nan(uint32_t const * v) {
2293  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2294  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2295  }
2296 
2297  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2298  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2299  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2300  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2301 public:
2302 
2304  static const float Infinity;
2306  static const float NegativeInfinity;
2307 
2309  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2310  static HPS_INLINE bool IsInfinite(double const & a) {
2311  uint32_t v[2];
2312  memcpy (v, &a, sizeof(double));
2313  return is_infinite (v);
2314  }
2315 
2317  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2318  static HPS_INLINE bool IsNAN(double const & a) {
2319  uint32_t v[2];
2320  memcpy (v, &a, sizeof(double));
2321  return is_nan (v);
2322  }
2323 
2325  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2326  static HPS_INLINE bool IsAbnormal(double const & a) {
2327  uint32_t v[2];
2328  memcpy (v, &a, sizeof(double));
2329  return is_special (v);
2330  }
2331 
2334  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2335  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2336 
2337 #ifndef HOOPS_DEFINED
2338  template <typename Alloc>
2339  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2340  {
2341  if (a.size() != b.size())
2342  return false;
2343 
2344  auto it1 = a.begin();
2345  auto it2 = b.begin();
2346  auto const end = a.end();
2347  for ( ; it1 != end; ++it1, ++it2)
2348  {
2349  if (!Equals(*it1, *it2, tolerance))
2350  return false;
2351  }
2352  return true;
2353  }
2354 #endif
2355 
2356  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2357  return extract_uint32_t(a) & 0x80000000;
2358  }
2359  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2360  uint32_t v[2];
2361  memcpy (v, &a, sizeof(double));
2362  return v[High] & 0x80000000;
2363  }
2364 
2365  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2366  uint32_t v = extract_uint32_t(a);
2367  v &= 0x7FFFFFFF;
2368  v |= sign_bit;
2369  inject_uint32_t(a, v);
2370  }
2371  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2372  uint32_t v[2];
2373  memcpy (v, &a, sizeof(double));
2374  v[High] &= 0x7FFFFFFF;
2375  v[High] |= sign_bit;
2376  memcpy (&a, v, sizeof(double));
2377  }
2378 
2379 
2380  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2381  uint32_t v = extract_uint32_t(a);
2382 
2383  v &= 0x7FFFFFFF;
2384  if (v < 0x3B800000)
2385  return 0;
2386 
2387  v--;
2388 
2389  uint32_t exp = v >> 23;
2390  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2391 
2392  return (unsigned char) (man >> (16 + 126 - exp));
2393  }
2394 
2395  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2396  uint32_t v = extract_uint32_t(a);
2397 
2398  v &= 0x7FFFFFFF;
2399  if (v < 0x3B800000)
2400  return 0;
2401 
2402  v--;
2403 
2404  uint32_t exp = v >> 23;
2405  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2406 
2407  uint32_t x = (man >> (16 + 126 - exp));
2408 
2409  return (unsigned char) ((x * (mix+1)) >> 8);
2410  }
2411 
2412 
2413  static HPS_INLINE bool match(float const & a, float const & b) {
2414  uint32_t va = extract_uint32_t(a);
2415  uint32_t vb = extract_uint32_t(b);
2416 
2417  if (((va | vb) & 0x7FFFFFFF) == 0)
2418  return true;
2419 
2420  return va == vb;
2421  }
2422  static HPS_INLINE bool match(double const & a, double const & b) {
2423  return a == b;
2424  }
2425 
2426 
2427  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2428  if (b < a)
2429  a = b;
2430  }
2431  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2432  if (b < a)
2433  a = b;
2434  }
2435 
2436  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2437  if (b > a)
2438  a = b;
2439  }
2440  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2441  if (b > a)
2442  a = b;
2443  }
2444 
2445 
2446  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2447  uint32_t i;
2448  memcpy(&i, &a, sizeof(float));
2449  return i;
2450  }
2451 
2452  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2453  memcpy(&a, &i, sizeof(float));
2454  }
2455 
2456  static HPS_INLINE float C2F(unsigned char x) {
2457  //return (float)x * (1.0f/255.0f);
2458  return char_to_float[x];
2459  }
2460 
2461 
2462  // SSE convenience functions
2463  static HPS_INLINE void pack_4(float const & f, float * m) {
2464  memcpy(&m[0], &f, sizeof(float));
2465  memcpy(&m[1], &f, sizeof(float));
2466  memcpy(&m[2], &f, sizeof(float));
2467  memcpy(&m[3], &f, sizeof(float));
2468  }
2469 
2470  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2471  memcpy(&m[0], &f0, sizeof(float));
2472  memcpy(&m[1], &f1, sizeof(float));
2473  memcpy(&m[2], &f2, sizeof(float));
2474  memcpy(&m[3], &f3, sizeof(float));
2475  }
2476 
2477  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2478  memcpy(f0, m, sizeof(float)*4);
2479  }
2480 
2481  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2482  memcpy(&f0, &m[0], sizeof(float));
2483  memcpy(&f1, &m[1], sizeof(float));
2484  memcpy(&f2, &m[2], sizeof(float));
2485  memcpy(&f3, &m[3], sizeof(float));
2486  }
2487 
2488 private:
2489  static const float char_to_float[256];
2490 
2491  Float();
2492 };
2493 
2494 
2496 
2497 
2498 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2499 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2500 
2501 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2502 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2503 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2504 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2505 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2506 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2507 
2508 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2509 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2510 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); }
2511 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); }
2512 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); }
2513 
2514 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2515 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2516 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); }
2517 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); }
2518 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); }
2519 
2520 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; }
2521 
2522 
2523 template <> HPS_INLINE float Abs<float> (float const & a) {
2524  uint32_t v = Float::extract_uint32_t(a);
2525  v &= 0x7FFFFFFF;
2526  float f;
2527  Float::inject_uint32_t(f,v);
2528  return f;
2529 }
2530 
2531 template <> HPS_INLINE int Sign<float> (float const & a) {
2532  uint32_t v = Float::extract_uint32_t(a);
2533 
2534  if ((v & 0x7FFFFFFF) == 0)
2535  return 0;
2536 
2537  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2538 }
2539 
2540 
2542 
2543 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2544  int32_t va = Float::extract_uint32_t(a);
2545  int32_t vb = Float::extract_uint32_t(b);
2546 
2547  if (is_special(va) || is_special(vb)) {
2548  if (is_infinite(va) || is_infinite(vb))
2549  return va == vb; // final check is for sign bits same
2550  if (is_nan(va) || is_nan(vb))
2551  return false;
2552  }
2553 
2554  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2555  if ((va & 0x7FFFFFFF) == 0)
2556  return (vb & 0x7FFFFFFF) < close_to_zero;
2557  else if ((vb & 0x7FFFFFFF) == 0)
2558  return (va & 0x7FFFFFFF) < close_to_zero;
2559 
2560  uint32_t sign_mask = va ^ vb;
2561  (int32_t &)sign_mask >>= 31;
2562 
2563  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2564  int32_t v1 = tolerance + diff;
2565  int32_t v2 = tolerance - diff;
2566  return (v1|v2) >= 0;
2567 }
2568 
2569 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2570  int32_t va[2], vb[2];
2571  memcpy (va, &a, sizeof(double));
2572  memcpy (vb, &b, sizeof(double));
2573 
2574  if (is_special(va) || is_special(vb)) {
2575  if (is_infinite(va) || is_infinite(vb))
2576  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2577  if (is_nan(va) || is_nan(vb))
2578  return false;
2579  }
2580 
2581  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2582  return Abs(a - b) < 0.000000000000005;
2583 
2584  if (extract_sign_bit(a) != extract_sign_bit(b))
2585  return a == b; //-V550
2586 
2587  if (va[High] != vb[High])
2588  return false;
2589 
2590  return Abs(va[Low] - vb[Low]) <= tolerance;
2591 }
2592 
2594 
2595 
2596 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2597 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2598 
2599 template <typename T>
2600 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2601  while (count-- > 0)
2602  if (Is_Abnormal (*t++))
2603  return true;
2604  return false;
2605 }
2606 
2607 template <typename T>
2608 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2609  return count >= 0 && Is_Abnormal((size_t)count, t);
2610 }
2611 
2612 
2614 
2615 
2616 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2617 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2618 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2619 template <typename F> class HPS_TEMPLATE_API Point_2D;
2620 
2621 
2622 template <typename F>
2623 class HPS_TEMPLATE_API Point_3D {
2624  public:
2625  F x;
2626  F y;
2627  F z;
2628 
2629  Point_3D () {}
2630  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2631 
2632  template <typename D>
2633  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2634 
2635  explicit Point_3D (Vector_3D<F> const & v);
2636  explicit Point_3D (Vector_2D<F> const & v);
2637  explicit Point_3D (Point_2D<F> const & that);
2638 
2639  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2640 
2641  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2642  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2643 
2644  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2645  return Float::Equals(x, p.x, in_tolerance) &&
2646  Float::Equals(y, p.y, in_tolerance) &&
2647  Float::Equals(z, p.z, in_tolerance);
2648  }
2649 
2650 
2651  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2652  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2653  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2654  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2655 
2656  F & operator[] (size_t i) { return (&x)[i]; }
2657  F const & operator[] (size_t i) const { return (&x)[i]; }
2658 
2659  Point_3D & operator+= (Vector_3D<F> const & v);
2660  Point_3D & operator-= (Vector_3D<F> const & v);
2661  Point_3D & operator*= (Vector_3D<F> const & v);
2662  Point_3D & operator/= (Vector_3D<F> const & v);
2663  Point_3D const operator* (Vector_3D<F> const & v) const;
2664  Point_3D const operator/ (Vector_3D<F> const & v) const;
2665 
2666  Point_3D & operator+= (Vector_2D<F> const & v);
2667  Point_3D & operator-= (Vector_2D<F> const & v);
2668  Point_3D & operator*= (Vector_2D<F> const & v);
2669  Point_3D & operator/= (Vector_2D<F> const & v);
2670  Point_3D const operator* (Vector_2D<F> const & v) const;
2671  Point_3D const operator/ (Vector_2D<F> const & v) const;
2672 
2673  Vector_3D<F> const operator- (Point_3D const & p) const;
2674 
2675  Point_3D const operator+ (Vector_3D<F> const & v) const;
2676  Point_3D const operator- (Vector_3D<F> const & v) const;
2677 
2678  Point_3D const operator+ (Vector_2D<F> const & v) const;
2679  Point_3D const operator- (Vector_2D<F> const & v) const;
2680 
2681  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2682  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2683 };
2684 
2685 typedef Point_3D<float> Point;
2686 typedef Point_3D<double> DPoint;
2687 
2688 
2689 
2690 template <typename F, typename S>
2691 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)); }
2692 
2693 template <typename F>
2694 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2695  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2696 }
2697 
2698 template <typename F>
2699 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2700  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);
2701 }
2702 
2703 template <typename F>
2704 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2705  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2706 }
2707 
2708 
2709 template <typename F>
2710 class HPS_TEMPLATE_API Point_2D {
2711 public:
2712  F x;
2713  F y;
2714 
2715  Point_2D () {}
2716  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2717 
2718  template <typename D>
2719  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2720 
2721  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2722  explicit Point_2D (Vector_2D<F> const & v);
2723 
2724  Point_2D const operator- () const { return Point_2D (-x, -y); }
2725 
2726  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2727  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2728 
2729  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2730  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2731  }
2732 
2733 
2734  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2735  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2736  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2737  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2738 
2739  F & operator[] (size_t i) { return (&x)[i]; }
2740  F const & operator[] (size_t i) const { return (&x)[i]; }
2741 
2742  Point_2D & operator+= (Vector_2D<F> const & v);
2743  Point_2D & operator-= (Vector_2D<F> const & v);
2744  Point_2D & operator*= (Vector_2D<F> const & v);
2745  Point_2D & operator/= (Vector_2D<F> const & v);
2746  Point_2D const operator* (Vector_2D<F> const & v) const;
2747  Point_2D const operator/ (Vector_2D<F> const & v) const;
2748 
2749  Vector_2D<F> const operator- (Point_2D const & p) const;
2750 
2751  Point_2D const operator+ (Vector_2D<F> const & v) const;
2752  Point_2D const operator- (Vector_2D<F> const & v) const;
2753 
2754  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2755  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2756 };
2757 
2758 typedef Point_2D<float> Point2D;
2759 typedef Point_2D<double> DPoint2D;
2760 
2761 template <typename F>
2762 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2763 
2764 template <typename F, typename S>
2765 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)); }
2766 
2767 template <typename F>
2768 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2769  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2770 }
2771 
2772 template <typename F>
2773 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2774  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);
2775 }
2776 
2777 template <typename F>
2778 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2779  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2780 }
2781 
2782 
2783 template <typename F>
2784 class HPS_TEMPLATE_API Vector_3D {
2785  public:
2786  F x;
2787  F y;
2788  F z;
2789 
2790  Vector_3D () {}
2791  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2792  template <typename D>
2793  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2794  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2795  explicit Vector_3D(Plane_3D<F> const & p);
2796 
2797  explicit Vector_3D (Vector_2D<F> const & that);
2798 
2799  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2800 
2801  bool operator== (Vector_3D const & v) const {
2802  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2803  }
2804  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2805 
2806  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2807  return Float::Equals(x, v.x, in_tolerance) &&
2808  Float::Equals(y, v.y, in_tolerance) &&
2809  Float::Equals(z, v.z, in_tolerance);
2810  }
2811 
2812  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2813  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2814  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2815  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2816 
2817  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2818  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2819  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2820  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2821 
2822  F & operator[] (size_t i) { return (&x)[i]; }
2823  F const & operator[] (size_t i) const { return (&x)[i]; }
2824 
2825  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2826 
2827  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2828 
2829  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2830 
2831  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2832 
2833  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2834  if (check_range) {
2835  F range = Max (Abs (x), Abs (y), Abs (z));
2836  if (range > F(1.0e10))
2837  operator/= (range);
2838  }
2839 
2840  F len = (F)Length();
2841  if (len > epsilon)
2842  operator/= (len);
2843  else
2844  *this = Zero();
2845  return *this;
2846  }
2847  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2848 
2849  HPS_INLINE Vector_3D & Clean_Zeroes (F epsilon = F(1.0e-4)) {
2850  if (Abs(x) < epsilon)
2851  x = 0;
2852  if (Abs(y) < epsilon)
2853  y = 0;
2854  if (Abs(z) < epsilon)
2855  z = 0;
2856  return *this;
2857  }
2858 
2859  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2860  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2861 
2862  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2863 
2864  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2865  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2866  }
2867 
2868 
2869  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2870  return Vector_3D (x * v.x, y * v.y, z * v.z);
2871  }
2872 
2873  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2874  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2875  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2876  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2877  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2878 };
2879 
2880 typedef Vector_3D<float> Vector;
2881 typedef Vector_3D<double> DVector;
2882 
2883 
2884 template <typename F, typename S>
2885 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)); }
2886 
2887 template <typename F>
2888 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2889  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2890 }
2891 
2892 
2893 template <typename F>
2894 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2895 
2896 template <typename F>
2897 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; }
2898 template <typename F>
2899 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; }
2900 
2901 template <typename F>
2902 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); }
2903 
2904 template <typename F>
2905 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); }
2906 template <typename F>
2907 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); }
2908 
2909 template <typename F>
2910 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; }
2911 template <typename F>
2912 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; }
2913 template <typename F>
2914 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); }
2915 template <typename F>
2916 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); }
2917 
2918 
2919 
2920 template <typename F>
2921 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2922  return a + (b - a) * t;
2923 }
2924 
2925 template <typename F>
2926 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2927  return Vector_3D<F>(a + (b - a) * t).Normalize();
2928 }
2929 
2930 
2931 
2932 template <typename F>
2933 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2934  return (p2 - p1).Length();
2935 }
2936 
2937 template <typename F>
2938 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2939  return (p2 - p1).LengthSquared();
2940 }
2941 
2942 template <typename F>
2943 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2944  F p = static_cast<F>((c - b).LengthSquared());
2945  F q = static_cast<F>((c - a).LengthSquared());
2946  F r = static_cast<F>((b - a).LengthSquared());
2947 
2948  return Point_3D<F>(
2949  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2950  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2951 }
2952 
2953 
2954 
2955 template <typename F>
2956 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2957  bool success = true;
2958  for (size_t i = 0; i < count; ++i) {
2959  if (vectors->Normalize() == Vector_3D<F>::Zero())
2960  success = false;
2961  vectors++;
2962  }
2963  return success;
2964 }
2965 
2966 
2967 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2968 
2969 template <typename F>
2970 class HPS_TEMPLATE_API Vector_2D {
2971 public:
2972  F x;
2973  F y;
2974 
2975  Vector_2D () {}
2976  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2977  template <typename D>
2978  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2979 
2980  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2981  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2982  explicit Vector_2D (Plane_2D<F> const & p);
2983 
2984  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2985 
2986  bool operator== (Vector_2D const & v) const {
2987  return Float::match(x, v.x) && Float::match(y, v.y);
2988  }
2989  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2990 
2991  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2992  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2993  }
2994 
2995  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2996  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2997  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2998  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2999 
3000  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
3001  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
3002  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
3003  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
3004 
3005  F & operator[] (size_t i) { return (&x)[i]; }
3006  F const & operator[] (size_t i) const { return (&x)[i]; }
3007 
3008  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
3009 
3010  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
3011 
3012  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
3013  if (check_range) {
3014  F range = Max (Abs (x), Abs (y));
3015  if (range > F(1.0e10))
3016  operator/= (range);
3017  }
3018 
3019  F len = (F)Length();
3020  if (len > epsilon)
3021  operator/= (len);
3022  else
3023  *this = Zero();
3024  return *this;
3025  }
3026  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
3027 
3028  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
3029  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
3030 
3031  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
3032 
3033 
3034  HPS_INLINE F Cross (Vector_2D const & v) const {
3035  return x * v.y - y * v.x;
3036  }
3037 
3038  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
3039  return Vector_2D (x * v.x, y * v.y);
3040  }
3041 
3042  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
3043  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
3044 
3045  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
3046  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
3047 };
3048 
3049 typedef Vector_2D<float> Vector2D;
3051 
3052 template <typename F, typename S>
3053 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)); }
3054 
3055 template <typename F>
3056 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
3057  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
3058 }
3059 
3060 
3061 template <typename F>
3062 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
3063 
3064 template <typename F>
3065 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
3066 
3067 template <typename F>
3068 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3069 template <typename F>
3070 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3071 
3072 template <typename F>
3073 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); }
3074 template <typename F>
3075 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); }
3076 
3077 template <typename F>
3078 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3079 template <typename F>
3080 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3081 
3082 template <typename F>
3083 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); }
3084 template <typename F>
3085 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); }
3086 
3087 
3088 template <typename F>
3089 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
3090 template <typename F>
3091 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
3092 
3093 template <typename F>
3094 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); }
3095 
3096 template <typename F>
3097 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); }
3098 template <typename F>
3099 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); }
3100 
3101 template <typename F>
3102 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
3103 template <typename F>
3104 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
3105 template <typename F>
3106 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); }
3107 template <typename F>
3108 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); }
3109 
3110 
3111 
3112 
3113 
3114 template <typename F>
3115 class HPS_TEMPLATE_API Plane_3D {
3116  public:
3117  F a;
3118  F b;
3119  F c;
3120  F d;
3121 
3122  Plane_3D () {}
3123  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3124  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
3125  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)) {}
3126  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)) {}
3127  template <typename D>
3128  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3129 
3130  Plane_3D (size_t count, Point_3D<F> const * points) {
3131  if (count >= 3) {
3132  // The 3 coefficients A, B, and C are proportional to the areas of the
3133  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3134 
3135  // run around the polygon, collecting trapezoidal areas
3136  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3137 
3138  // take care of the swing point first
3139  Point_3D<F> const * p0 = &points[count-1];
3140 
3142  Vector_3D<F> normal = Vector_3D<F>::Zero();
3143 
3144  for (size_t i=0; i<count; ++i) {
3145  Point_3D<F> const * p1 = &points[i];
3146 
3147  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3148  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3149  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3150 
3151  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3152 
3153  p0 = p1;
3154  }
3155 
3156  // ("should" always be != 0)
3157  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3158  /* finish finding the average */
3159  double inv_count = 1.0 / (double)count;
3160  ctr *= inv_count;
3161 
3162  *this = Plane_3D(normal, Point_3D<F>(ctr));
3163  return;
3164  }
3165  }
3166 
3167  *this = Plane_3D::Zero();
3168  }
3169 
3170 
3171  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3172 
3173  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3174  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3175 
3176  F & operator[] (size_t i) { return (&a)[i]; }
3177  F const & operator[] (size_t i) const { return (&a)[i]; }
3178 
3179  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3180  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3181  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3182  }
3183 
3184  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3185  F len = (F)Vector_3D<F>(*this).Length();
3186  if (len > epsilon)
3187  operator/= (len);
3188  else
3189  *this = Zero();
3190  return *this;
3191  }
3192 
3193  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3194  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3195  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3196 
3197  if (val1 >= eps) {
3198  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3199  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3200  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3201  }
3202  else
3203  return p1;
3204  }
3205 
3206  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3207  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3208  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3209 
3210  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));
3211  }
3212 
3213  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3214 
3215 
3216  private:
3217  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3218  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3219  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3220  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3221 };
3222 
3223 typedef Plane_3D<float> Plane;
3224 typedef Plane_3D<double> DPlane;
3225 
3226 
3227 template <typename F>
3228 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3229  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3230 }
3231 
3232 
3233 template <typename F>
3234 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3235  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3236 }
3237 template <typename F>
3238 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3239  return plane * point;
3240 }
3241 
3242 template <typename F>
3243 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3244  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);
3245 }
3246 
3247 template <typename F>
3248 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3249 
3250 
3251 
3252 
3253 
3254 
3255 template <typename F>
3256 class HPS_TEMPLATE_API Plane_2D {
3257 public:
3258  F a;
3259  F b;
3260  F c;
3261 
3262  Plane_2D () {}
3263  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3264  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3265  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)) {}
3266  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)) {}
3267  template <typename D>
3268  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3269 
3270  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3271 
3272  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3273  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3274 
3275  F & operator[] (size_t i) { return (&a)[i]; }
3276  F const & operator[] (size_t i) const { return (&a)[i]; }
3277 
3278  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3279  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3280  }
3281 
3282  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3283  F len = (F)Vector_2D<F>(*this).Length();
3284  if (len > epsilon)
3285  operator/= (len);
3286  else
3287  *this = Zero();
3288  return *this;
3289  }
3290 
3291  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3292 
3293 
3294 private:
3295  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3296  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3297  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3298  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3299 };
3300 
3301 typedef Plane_2D<float> Plane2D;
3302 typedef Plane_2D<double> DPlane2D;
3303 
3304 
3305 template <typename F>
3306 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3307  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3308 }
3309 
3310 
3311 template <typename F>
3312 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3313  return plane.a * point.x + plane.b * point.y + plane.c;
3314 }
3315 template <typename F>
3316 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3317  return plane * point;
3318 }
3319 
3320 template <typename F>
3321 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3322  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);
3323 }
3324 
3325 template <typename F>
3326 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3327 
3328 
3329 
3330 
3331 struct Rectangle;
3332 
3333 struct HPS_API IntRectangle {
3334  int left;
3335  int right;
3336  int bottom;
3337  int top;
3338 
3339  IntRectangle()
3340  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3341  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3342 
3343  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3344  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3345 
3346  IntRectangle(IntRectangle const & that)
3347  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3348 
3349  explicit IntRectangle(Rectangle const & that);
3350 
3351  bool operator==(IntRectangle const & rect) const {
3352  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3353  }
3354 
3355  bool operator!=(IntRectangle const & rect) const {
3356  return !(*this == rect);
3357  }
3358 
3359  HPS_INLINE int PixelWidth() const {
3360  return right - left + 1;
3361  }
3362 
3363  HPS_INLINE int PixelHeight() const {
3364  return top - bottom + 1;
3365  }
3366 
3367  HPS_INLINE int Width() const {
3368  return right - left;
3369  }
3370 
3371  HPS_INLINE int Height() const {
3372  return top - bottom;
3373  }
3374 
3375  HPS_INLINE int Area() const {
3376  return Width() * Height();
3377  }
3378 
3379  HPS_INLINE float Aspect() const {
3380  return (float)Height() / (float)Width();
3381  }
3382 
3383  HPS_INLINE Point2D Center() const {
3384  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3385  }
3386 
3387  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3388  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3389  }
3390 
3391  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3392  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3393  }
3394 
3395  HPS_INLINE IntRectangle & Expand(int border) {
3396  left -= border;
3397  right += border;
3398  bottom -= border;
3399  top += border;
3400  return *this;
3401  }
3402 
3403  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3404  left -= rect.left;
3405  right += rect.right;
3406  bottom -= rect.bottom;
3407  top += rect.top;
3408  return *this;
3409  }
3410 
3411  HPS_INLINE IntRectangle & Contract(int border) {
3412  left += border;
3413  right -= border;
3414  bottom += border;
3415  top -= border;
3416  return *this;
3417  }
3418 
3419  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3420  left += rect.left;
3421  right -= rect.right;
3422  bottom += rect.bottom;
3423  top -= rect.top;
3424  return *this;
3425  }
3426 
3427  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3428  left = Max(left, rect.left);
3429  right = Min(right, rect.right);
3430  bottom = Max(bottom, rect.bottom);
3431  top = Min(top, rect.top);
3432  return *this;
3433  }
3434 
3435  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3436  left = Min(left, rect.left);
3437  right = Max(right, rect.right);
3438  bottom = Min(bottom, rect.bottom);
3439  top = Max(top, rect.top);
3440  return *this;
3441  }
3442 
3443 
3444  static HPS_INLINE IntRectangle Invalid() {
3445  return IntRectangle();
3446  }
3447 
3448  static HPS_INLINE IntRectangle Zero() {
3449  return IntRectangle(0, 0, 0, 0);
3450  }
3451 
3452 };
3453 
3454 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3455  IntRectangle temp = a;
3456  return temp.Expand(border);
3457 }
3458 
3459 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3460  IntRectangle temp = a;
3461  return temp.Expand(border);
3462 }
3463 
3464 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3465  IntRectangle temp = a;
3466  return temp.Contract(border);
3467 }
3468 
3469 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3470  IntRectangle temp = a;
3471  return temp.Contract(border);
3472 }
3473 
3474 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3475  IntRectangle temp = a;
3476  return temp.Intersect(b);
3477 }
3478 
3479 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3480  IntRectangle temp = a;
3481  return temp.Union(b);
3482 }
3483 
3484 struct HPS_API Rectangle {
3485  float left;
3486  float right;
3487  float bottom;
3488  float top;
3489 
3490  Rectangle()
3491  : left(std::numeric_limits<float>::max()), right(-std::numeric_limits<float>::max()),
3492  bottom(std::numeric_limits<float>::max()), top(-std::numeric_limits<float>::max()) {}
3493 
3494  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3495  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3496 
3497  Rectangle(Rectangle const & that)
3498  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3499 
3500  explicit Rectangle(IntRectangle const & that)
3501  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3502 
3503  HPS_INLINE Rectangle(size_t count, Point const * points) {
3504  left = points->x;
3505  right = points->x;
3506  top = points->y;
3507  bottom = points->y;
3508  --count;
3509  if (count > 0) {
3510  ++points;
3511  Merge(count, points);
3512  }
3513  }
3514 
3515  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3516  left = points->x;
3517  right = points->x;
3518  top = points->y;
3519  bottom = points->y;
3520  --count;
3521  if (count > 0) {
3522  ++points;
3523  Merge(count, points);
3524  }
3525  }
3526 
3527  HPS_INLINE float Width() const {
3528  return right - left;
3529  }
3530 
3531  HPS_INLINE float Height() const {
3532  return top - bottom;
3533  }
3534 
3535  HPS_INLINE float Area() const {
3536  return Width() * Height();
3537  }
3538 
3539  HPS_INLINE float Aspect() const {
3540  return Height() / Width();
3541  }
3542 
3543  HPS_INLINE Point2D Center() const {
3544  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3545  }
3546 
3547  HPS_INLINE void Merge(size_t count, Point const * points) {
3548 
3549  while (count > 1) {
3550  if (points[0].x > points[1].x) {
3551  Float::replace_if_smaller(left, points[1].x);
3552  Float::replace_if_larger(right, points[0].x);
3553  }
3554  else {
3555  Float::replace_if_smaller(left, points[0].x);
3556  Float::replace_if_larger(right, points[1].x);
3557  }
3558 
3559  if (points[0].y > points[1].y) {
3560  Float::replace_if_smaller(bottom, points[1].y);
3561  Float::replace_if_larger(top, points[0].y);
3562  }
3563  else {
3564  Float::replace_if_smaller(bottom, points[0].y);
3565  Float::replace_if_larger(top, points[1].y);
3566  }
3567 
3568  points += 2;
3569  count -= 2;
3570  }
3571 
3572  if (count > 0)
3573  Merge(*points);
3574  }
3575 
3576  HPS_INLINE void Merge(Point const & point) {
3577  Float::replace_if_smaller(left, point.x);
3578  Float::replace_if_smaller(bottom, point.y);
3579  Float::replace_if_larger(right, point.x);
3580  Float::replace_if_larger(top, point.y);
3581  }
3582 
3583  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3584 
3585  while (count > 1) {
3586  if (points[0].x > points[1].x) {
3587  Float::replace_if_smaller(left, points[1].x);
3588  Float::replace_if_larger(right, points[0].x);
3589  }
3590  else {
3591  Float::replace_if_smaller(left, points[0].x);
3592  Float::replace_if_larger(right, points[1].x);
3593  }
3594 
3595  if (points[0].y > points[1].y) {
3596  Float::replace_if_smaller(bottom, points[1].y);
3597  Float::replace_if_larger(top, points[0].y);
3598  }
3599  else {
3600  Float::replace_if_smaller(bottom, points[0].y);
3601  Float::replace_if_larger(top, points[1].y);
3602  }
3603 
3604  points += 2;
3605  count -= 2;
3606  }
3607 
3608  if (count > 0)
3609  Merge(*points);
3610  }
3611 
3612  HPS_INLINE void Merge(Point2D const & point) {
3613  Float::replace_if_smaller(left, point.x);
3614  Float::replace_if_smaller(bottom, point.y);
3615  Float::replace_if_larger(right, point.x);
3616  Float::replace_if_larger(top, point.y);
3617  }
3618 
3619  HPS_INLINE bool operator==(Rectangle const & rect) const {
3620  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3621  }
3622 
3623  HPS_INLINE bool operator!=(Rectangle const & rect) const {
3624  return !(*this == rect);
3625  }
3626 
3627  HPS_INLINE bool Equals(Rectangle const & rect, int in_tolerance = 32) const {
3628  return Float::Equals(left, rect.left, in_tolerance) &&
3629  Float::Equals(right, rect.right, in_tolerance) &&
3630  Float::Equals(top, rect.top, in_tolerance) &&
3631  Float::Equals(bottom, rect.bottom, in_tolerance);
3632  }
3633 
3634  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3635  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3636  }
3637 
3638  HPS_INLINE bool Contains(Point const & contained) const {
3639  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3640  }
3641 
3642  HPS_INLINE bool Contains(Point2D const & contained) const {
3643  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3644  }
3645 
3646  HPS_INLINE bool Contains(Rectangle const & rect) {
3647  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3648  }
3649 
3650  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3651  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3652  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3653  }
3654 
3655  HPS_INLINE Rectangle & Expand(float border) {
3656  left -= border;
3657  right += border;
3658  bottom -= border;
3659  top += border;
3660  return *this;
3661  }
3662 
3663  HPS_INLINE Rectangle & Expand(int border) {
3664  Expand((float)border);
3665  return *this;
3666  }
3667 
3668  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3669  left -= rect.left;
3670  right += rect.right;
3671  bottom -= rect.bottom;
3672  top += rect.top;
3673  return *this;
3674  }
3675 
3676  HPS_INLINE Rectangle & Contract(int border) {
3677  left += border;
3678  right -= border;
3679  bottom += border;
3680  top -= border;
3681  return *this;
3682  }
3683 
3684  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3685  left += rect.left;
3686  right -= rect.right;
3687  bottom += rect.bottom;
3688  top -= rect.top;
3689  return *this;
3690  }
3691 
3692  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3693  left = Max(left, rect.left);
3694  right = Min(right, rect.right);
3695  bottom = Max(bottom, rect.bottom);
3696  top = Min(top, rect.top);
3697  return *this;
3698  }
3699 
3700  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3701  left = Min(left, rect.left);
3702  right = Max(right, rect.right);
3703  bottom = Min(bottom, rect.bottom);
3704  top = Max(top, rect.top);
3705  return *this;
3706  }
3707 
3708  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3709  float scale = (scope.right - scope.left) * 0.5f;
3710  float trans = (scope.right + scope.left) * 0.5f;
3711 
3712  left = left * scale + trans;
3713  right = right * scale + trans;
3714 
3715  scale = (scope.top - scope.bottom) * 0.5f;
3716  trans = (scope.top + scope.bottom) * 0.5f;
3717 
3718  bottom = bottom * scale + trans;
3719  top = top * scale + trans;
3720  return *this;
3721  }
3722 
3723  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3724  float tmp = 2.0f/(scope.right - scope.left);
3725  right = (right - scope.left) * tmp - 1.0f;
3726  left = (left - scope.left) * tmp - 1.0f;
3727 
3728  tmp = 2.0f/(scope.top - scope.bottom);
3729  top = (top - scope.bottom) * tmp - 1.0f;
3730  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3731  return *this;
3732  }
3733 
3734  static HPS_INLINE Rectangle FullScope() {
3735  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3736  }
3737 
3738  static HPS_INLINE Rectangle InvalidScope() {
3739  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3740  }
3741 
3742  static HPS_INLINE Rectangle Zero() {
3743  return Rectangle(0, 0, 0, 0);
3744  }
3745 
3746 };
3747 
3748 
3749 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3750  IntRectangle temp;
3751  temp.left = Floor (a.left);
3752  temp.right = Floor (a.right);
3753  temp.bottom = Floor (a.bottom);
3754  temp.top = Floor (a.top);
3755  return temp;
3756 }
3757 
3758 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3759  Rectangle temp = a;
3760  return temp.Expand(border);
3761 }
3762 
3763 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3764  Rectangle temp = a;
3765  return temp.Expand(border);
3766 }
3767 
3768 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3769  Rectangle temp = a;
3770  return temp.Contract(border);
3771 }
3772 
3773 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3774  Rectangle temp = a;
3775  return temp.Contract(border);
3776 }
3777 
3778 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3779  Rectangle temp = a;
3780  return temp.Intersect(b);
3781 }
3782 
3783 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3784  Rectangle temp = a;
3785  return temp.Union(b);
3786 }
3787 
3788 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3789  Rectangle temp = a;
3790  return temp.Inscribe_Scope(scope);
3791 }
3792 
3793 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3794  Rectangle temp = a;
3795  return temp.Circumscribe_Scope(scope);
3796 }
3797 
3798 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3799  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3800 
3801 
3802 
3803 
3804 template <typename F>
3805 struct Sphere_3D;
3806 
3807 template <typename F>
3808 struct HPS_TEMPLATE_API Cuboid_3D {
3813 
3814 
3818  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3819 
3820  template <typename D>
3821 
3826  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3827 
3828 
3833  Cuboid_3D (Sphere_3D<F> const & that);
3834 
3840  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3841 
3847  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3848  if (count == 0) {
3849  min = Limit_Point();
3850  max = -Limit_Point();
3851  return;
3852  }
3853  min = max = *points++;
3854  --count;
3855  if (count>0)
3856  Merge(count, points);
3857  }
3858 
3863  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3864 
3868  HPS_INLINE bool IsValid() const {
3869  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3870  }
3871 
3875  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3876 
3880  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3881 
3886  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3887 
3892  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3893 
3898  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3899  points[0] = Point_3D<F> (min.x, min.y, min.z);
3900  points[1] = Point_3D<F> (min.x, min.y, max.z);
3901  points[2] = Point_3D<F> (min.x, max.y, min.z);
3902  points[3] = Point_3D<F> (min.x, max.y, max.z);
3903  points[4] = Point_3D<F> (max.x, min.y, min.z);
3904  points[5] = Point_3D<F> (max.x, min.y, max.z);
3905  points[6] = Point_3D<F> (max.x, max.y, min.z);
3906  points[7] = Point_3D<F> (max.x, max.y, max.z);
3907  }
3908 
3912  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3913 
3917  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3918 
3924  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3925  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3926  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3927  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3928  }
3929 
3935  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3936  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3937  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3938  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3939  }
3940 
3947  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3948  //ASSERT (0 <= dimension && dimension <= 2);
3949  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3950  }
3951 
3959  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3960  //ASSERT (0 <= dimension && dimension <= 2);
3961  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3962  }
3963 
3970  HPS_INLINE bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const {
3971  return LineIntersecting(start, direction, true);
3972  }
3973 
3980  HPS_INLINE bool Intersecting (Point_3D<F> const & point1, Point_3D<F> const & point2) const {
3981  Vector_3D<F> const direction = point2 - point1;
3982  return LineIntersecting(point1, direction, false);
3983  }
3984 
3990  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3991  Float::replace_if_smaller(min.x, cuboid.min.x);
3992  Float::replace_if_smaller(min.y, cuboid.min.y);
3993  Float::replace_if_smaller(min.z, cuboid.min.z);
3994  Float::replace_if_larger(max.x, cuboid.max.x);
3995  Float::replace_if_larger(max.y, cuboid.max.y);
3996  Float::replace_if_larger(max.z, cuboid.max.z);
3997  }
3998 
4004  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
4005 
4011  HPS_INLINE void Merge(Point_3D<F> const & point) {
4012  Float::replace_if_smaller(min.x, point.x);
4013  Float::replace_if_smaller(min.y, point.y);
4014  Float::replace_if_smaller(min.z, point.z);
4015  Float::replace_if_larger(max.x, point.x);
4016  Float::replace_if_larger(max.y, point.y);
4017  Float::replace_if_larger(max.z, point.z);
4018  }
4019 
4026  void Merge(size_t count, Point_3D<F> const * points) {
4027  while (count > 1) {
4028  if (points[0].x > points[1].x) {
4029  Float::replace_if_smaller(min.x, points[1].x);
4030  Float::replace_if_larger(max.x, points[0].x);
4031  }
4032  else {
4033  Float::replace_if_smaller(min.x, points[0].x);
4034  Float::replace_if_larger(max.x, points[1].x);
4035  }
4036 
4037  if (points[0].y > points[1].y) {
4038  Float::replace_if_smaller(min.y, points[1].y);
4039  Float::replace_if_larger(max.y, points[0].y);
4040  }
4041  else {
4042  Float::replace_if_smaller(min.y, points[0].y);
4043  Float::replace_if_larger(max.y, points[1].y);
4044  }
4045 
4046  if (points[0].z > points[1].z) {
4047  Float::replace_if_smaller(min.z, points[1].z);
4048  Float::replace_if_larger(max.z, points[0].z);
4049  }
4050  else {
4051  Float::replace_if_smaller(min.z, points[0].z);
4052  Float::replace_if_larger(max.z, points[1].z);
4053  }
4054 
4055  points += 2;
4056  count -= 2;
4057  }
4058 
4059  if (count > 0)
4060  Merge(*points);
4061  }
4062 
4068  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
4069  return (contained.min.x >= min.x &&
4070  contained.min.y >= min.y &&
4071  contained.min.z >= min.z &&
4072  contained.max.x <= max.x &&
4073  contained.max.y <= max.y &&
4074  contained.max.z <= max.z);
4075  }
4076 
4082  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
4083  return (contained.x >= min.x &&
4084  contained.y >= min.y &&
4085  contained.z >= min.z &&
4086  contained.x <= max.x &&
4087  contained.y <= max.y &&
4088  contained.z <= max.z);
4089  }
4090 
4097  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
4098  return (contained.x >= min.x - epsilon &&
4099  contained.y >= min.y - epsilon &&
4100  contained.z >= min.z - epsilon &&
4101  contained.x <= max.x + epsilon &&
4102  contained.y <= max.y + epsilon &&
4103  contained.z <= max.z + epsilon);
4104  }
4105 
4111  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
4112  Float::replace_if_larger(min.x, cuboid.min.x);
4113  Float::replace_if_larger(min.y, cuboid.min.y);
4114  Float::replace_if_larger(min.z, cuboid.min.z);
4115  Float::replace_if_smaller(max.x, cuboid.max.x);
4116  Float::replace_if_smaller(max.y, cuboid.max.y);
4117  Float::replace_if_smaller(max.z, cuboid.max.z);
4118  return *this;
4119  }
4120 
4126  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
4127  Float::replace_if_smaller(min.x, cuboid.min.x);
4128  Float::replace_if_smaller(min.y, cuboid.min.y);
4129  Float::replace_if_smaller(min.z, cuboid.min.z);
4130  Float::replace_if_larger(max.x, cuboid.max.x);
4131  Float::replace_if_larger(max.y, cuboid.max.y);
4132  Float::replace_if_larger(max.z, cuboid.max.z);
4133  return *this;
4134  }
4135 
4141  HPS_INLINE Cuboid_3D & Expand(F border) {
4142  Vector_3D<F> delta (border, border, border);
4143  min -= delta;
4144  max += delta;
4145  return *this;
4146  }
4147 
4153  HPS_INLINE Cuboid_3D & Contract(F border) {
4154  Vector_3D<F> delta (border, border, border);
4155  min += delta;
4156  max -= delta;
4157  return *this;
4158  }
4159 
4160 private:
4161  HPS_INLINE static Point_3D<F> Limit_Point () {
4162  F const x = std::numeric_limits<F>::max();
4163  return Point_3D<F> (x, x, x);
4164  }
4165 
4166  bool LineIntersecting (Point_3D<F> const & start, Vector_3D<F> const & direction, bool is_ray) const;
4167 };
4168 
4169 typedef Cuboid_3D<float> SimpleCuboid;
4170 typedef Cuboid_3D<double> DSimpleCuboid;
4171 
4172 
4173 template <typename F>
4174 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4175  Cuboid_3D<F> temp = a;
4176  return temp.Intersect(b);
4177 }
4178 
4179 template <typename F>
4180 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4181  Cuboid_3D<F> temp = a;
4182  return temp.Union(b);
4183 }
4184 
4185 template <typename F>
4186 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4187  Cuboid_3D<F> temp = a;
4188  return temp.Expand(border);
4189 }
4190 
4191 template <typename F>
4192 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4193  Cuboid_3D<F> temp = a;
4194  return temp.Contract(border);
4195 }
4196 
4197 
4198 
4199 template <typename F>
4200 struct HPS_TEMPLATE_API Sphere_3D {
4201  Point_3D<F> center;
4202  F radius;
4203 
4204  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(-1) {}
4205 
4206  template <typename D>
4207  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4208 
4209  Sphere_3D (Cuboid_3D<F> const & cuboid) {
4210  if (cuboid.max.x < cuboid.min.x || cuboid.max.y < cuboid.min.y || cuboid.max.z < cuboid.min.z)
4211  *this = Invalid();
4212  else {
4213  center = Midpoint(cuboid.min, cuboid.max);
4214  radius = F(0.5 * cuboid.Diagonal().Length());
4215  }
4216  }
4217 
4218  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4219 
4220  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4221  Cuboid_3D<F> cuboid(count, points);
4222  center = Midpoint(cuboid.min, cuboid.max);
4223  Engulf (count, points);
4224  }
4225 
4226  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4227  Engulf (count, points);
4228  }
4229 
4230  HPS_INLINE bool IsValid() const {
4231  return radius >= 0;
4232  }
4233 
4234  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4235 
4236  void Invalidate() {radius = -1;}
4237 
4238  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4239  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4240 
4241  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4242 
4243  HPS_INLINE void Merge(Point_3D<F> const & point) {
4244  Vector_3D<F> dir = point - center;
4245  F distance = (F)dir.Length();
4246 
4247  if (distance > radius) {
4248  F t = F(0.5) * (distance - radius);
4249  center += t * dir.Normalize();
4250  radius += t;
4251  }
4252  }
4253 
4254  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4255  F radius_squared = radius * radius;
4256  for (size_t i = 0; i < count; ++i) {
4257  Vector_3D<F> dir = *points - center;
4258  F distance_squared = (F)dir.LengthSquared();
4259 
4260  if (distance_squared > radius_squared) {
4261  F distance = sqrt(distance_squared);
4262  F t = F(0.5) * ( distance - radius);
4263  center += t * (distance > Float_Traits<F>::Epsilon() ? dir / distance : Vector_3D<F>::Zero());
4264  radius += t;
4265  radius_squared = radius * radius;
4266  }
4267 
4268  ++points;
4269  }
4270  }
4271 
4272  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4273  Vector_3D<F> dir = sphere.center - center;
4274  F distance = (F)dir.Length();
4275 
4276  if (distance + sphere.radius > radius) {
4277  if (distance + radius > sphere.radius) {
4278  F t = F(0.5 * (sphere.radius + distance - radius));
4279  center += t * dir.Normalize();
4280  radius += t;
4281  }
4282  else {
4283  center = sphere.center;
4284  radius = sphere.radius;
4285  }
4286  }
4287  }
4288 
4289  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4290 
4291 private:
4292  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4293  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4294  for (size_t i = 0; i < count; ++i) {
4295  double dsq = (*points++ - center).LengthSquared();
4296  if ((F)dsq > radius * radius)
4297  radius = (F)sqrt(dsq);
4298  }
4299  }
4300 };
4301 
4302 typedef Sphere_3D<float> SimpleSphere;
4303 typedef Sphere_3D<double> DSimpleSphere;
4304 
4305 
4306 template <typename F>
4307 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4308  if (sphere.radius < 0)
4309  *this = Invalid();
4310  else {
4311  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4312  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4313  }
4314 }
4315 
4316 
4317 
4318 
4319 class RGB24Color;
4320 class RGBA32Color;
4321 class RGBAS32Color;
4322 class RGBAColor;
4323 
4324 class HPS_API RGBColor {
4325 public:
4326  float red;
4327  float green;
4328  float blue;
4329 
4330  HPS_INLINE RGBColor () {}
4331  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4332  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4333  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4334  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4335  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4336  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4337 
4338  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4339  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4340  float Distance(RGBColor const & other_color) const;
4341  HPS_INLINE bool IsValid() const {
4342  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4343  }
4344 
4345  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4346  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4347 
4348  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4349  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4350 
4351  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4352  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4353  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4354  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4355  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4356  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4357 
4358  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4359  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4360  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4361  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4362  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4363  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4364  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4365  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4366 
4367  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4368  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4369  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4370 
4371  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4372  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4373  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4374 
4375  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4376  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4377  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4378 };
4379 
4380 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4381 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4382 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4383 
4384 
4385 class HPS_API RGBAColor {
4386 public:
4387 
4388  float red;
4389  float green;
4390  float blue;
4391  float alpha;
4393  HPS_INLINE RGBAColor () {}
4394  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4395  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4396 
4397  HPS_INLINE RGBAColor (RGBColor const & c) {
4398  memcpy(this, &c, sizeof(RGBColor)); //-V512
4399  alpha = 1.0f;
4400  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4401  }
4402  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4403  memcpy(this, &c, sizeof(RGBColor));
4404  memcpy(&alpha, &a, sizeof(float));
4405  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4406  }
4407  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4408  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4409 
4410  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4411  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4412  HPS_INLINE bool IsValid() const {
4413  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4414  }
4415 
4422  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4423 
4430  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4431 
4432  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4433  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4434  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4435  }
4436 
4437  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4438  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4439  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4440  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4441  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4442  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4443 
4444  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4445  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4446  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4447  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4448  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4449  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4450  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4451  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4452 
4453  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4454  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4455  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4456  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4457  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4458  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4459 
4460  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4461  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4462  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4463  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4464 };
4465 
4466 
4467 
4469 public:
4470  enum Order {
4471  Order_ABGR,
4472  Order_RGBA,
4473  Order_BGRA
4474  };
4475 
4476 #ifdef _MSC_VER
4477  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4478  unsigned char b, g, r, a;
4479 #endif
4480 
4481 #ifdef __linux__
4482  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4483  unsigned char r, g, b, a;
4484 #endif
4485 
4486 #ifdef __APPLE_CC__
4487  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4488  unsigned char r, g, b, a;
4489 #endif
4490 };
4491 
4492 
4493 
4495 public:
4496 
4497  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4498  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4499  r = gray;
4500  g = gray;
4501  b = gray;
4502  a = aa;
4503  }
4504  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4505  r = rr;
4506  g = gg;
4507  b = bb;
4508  a = aa;
4509  }
4510  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4511 
4512  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4513  {
4514  r = Float::unit_to_byte(c.red);
4515  g = Float::unit_to_byte(c.green);
4516  b = Float::unit_to_byte(c.blue);
4517  a = 255;
4518  }
4519 
4520  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4521 
4522  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4523 
4524  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4525  {
4526  r = Float::unit_to_byte(c.red);
4527  g = Float::unit_to_byte(c.green);
4528  b = Float::unit_to_byte(c.blue);
4529  a = Float::unit_to_byte(alpha);
4530  }
4531  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4532  {
4533  r = Float::unit_to_byte(c.red);
4534  g = Float::unit_to_byte(c.green);
4535  b = Float::unit_to_byte(c.blue);
4536  a = aa;
4537  }
4538  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4539  {
4540  r = Float::unit_to_byte(c.red);
4541  g = Float::unit_to_byte(c.green);
4542  b = Float::unit_to_byte(c.blue);
4543  a = Float::unit_to_byte(c.alpha);
4544  }
4545  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4546  {
4547  r = Float::unit_to_byte(c.red);
4548  g = Float::unit_to_byte(c.green);
4549  b = Float::unit_to_byte(c.blue);
4550  a = Float::unit_to_byte_scaled(c.alpha, mix);
4551  }
4552 
4553  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4554  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4555  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4556 
4557  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4558  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4559 
4560  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4561  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4562  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4563 
4564  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4565 };
4566 
4568 public:
4569  unsigned char r;
4570  unsigned char g;
4571  unsigned char b;
4572  unsigned char a;
4573 
4574  HPS_INLINE RGBA32Color () {}
4575  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4576  : r (gray), g (gray), b (gray), a (aa) {}
4577  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4578  : r (rr), g (gg), b (bb), a (aa) {}
4579  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4580  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4581  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4582  r = Float::unit_to_byte(c.red);
4583  g = Float::unit_to_byte(c.green);
4584  b = Float::unit_to_byte(c.blue);
4585  a = 255;
4586  }
4587  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4588  r = Float::unit_to_byte(c.red);
4589  g = Float::unit_to_byte(c.green);
4590  b = Float::unit_to_byte(c.blue);
4591  a = Float::unit_to_byte(alpha);
4592  }
4593  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4594  r = Float::unit_to_byte(c.red);
4595  g = Float::unit_to_byte(c.green);
4596  b = Float::unit_to_byte(c.blue);
4597  a = aa;
4598  }
4599  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4600  r = Float::unit_to_byte(c.red);
4601  g = Float::unit_to_byte(c.green);
4602  b = Float::unit_to_byte(c.blue);
4603  a = Float::unit_to_byte(c.alpha);
4604  }
4605  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4606  r = Float::unit_to_byte(c.red);
4607  g = Float::unit_to_byte(c.green);
4608  b = Float::unit_to_byte(c.blue);
4609  a = Float::unit_to_byte_scaled(c.alpha, mix);
4610  }
4611 
4612  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4613  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4614 
4615  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4616  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4617 
4618  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4619  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4620 
4621  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4622 };
4623 
4624 
4626 {
4627 public:
4628  unsigned char r;
4629  unsigned char g;
4630  unsigned char b;
4631 
4632  HPS_INLINE RGB24Color () {}
4633  explicit HPS_INLINE RGB24Color (unsigned char gray)
4634  : r (gray), g (gray), b (gray) {}
4635  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4636  : r (rr), g (gg), b (bb) {}
4637  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4638  r = Float::unit_to_byte(c.red);
4639  g = Float::unit_to_byte(c.green);
4640  b = Float::unit_to_byte(c.blue);
4641  }
4642 
4643  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4644  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4645 
4646  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4647  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4648 };
4649 
4650 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4651  red = Float::C2F(c32.r);
4652  green = Float::C2F(c32.g);
4653  blue = Float::C2F(c32.b);
4654 }
4655 
4656 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4657  red = Float::C2F(c32.r);
4658  green = Float::C2F(c32.g);
4659  blue = Float::C2F(c32.b);
4660 }
4661 
4662 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4663  red = c.red;
4664  green = c.green;
4665  blue = c.blue;
4666 }
4667 
4668 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4669  red = Float::C2F(c24.r);
4670  green = Float::C2F(c24.g);
4671  blue = Float::C2F(c24.b);
4672 }
4673 
4674 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4675 {
4676  r = c.r;
4677  g = c.g;
4678  b = c.b;
4679  a = 255;
4680 }
4681 
4682 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4683 {
4684  r = c.r;
4685  g = c.g;
4686  b = c.b;
4687  a = c.a;
4688 }
4689 
4690 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4691  red = Float::C2F(c32.r);
4692  green = Float::C2F(c32.g);
4693  blue = Float::C2F(c32.b);
4694  alpha = Float::C2F(c32.a);
4695 }
4696 
4697 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4698  red = Float::C2F(c32.r);
4699  green = Float::C2F(c32.g);
4700  blue = Float::C2F(c32.b);
4701  alpha = Float::C2F(c32.a);
4702 }
4703 
4704 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4705  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4706 }
4707 
4708 
4709 
4710 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4711  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4712 }
4713 
4714 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4715  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);
4716 }
4717 
4718 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4719  return RGBAS32Color(
4720  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4721  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4722  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4723  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4724 }
4725 
4726 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4727  return RGBA32Color(
4728  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4729  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4730  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4731  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4732 }
4733 
4734 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4735  return RGB24Color(
4736  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4737  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4738  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4739 }
4740 
4741 
4742 
4743 class HPS_API Quaternion {
4744 public:
4745  float w;
4746  float x;
4747  float y;
4748  float z;
4749 
4750  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4751 
4752  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) { }
4753 
4754  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4755 
4756  Quaternion const & Normalize() {
4757  float mag = Norm();
4758 
4759  if (mag > 0) {
4760  w /= mag;
4761  x /= mag;
4762  y /= mag;
4763  z /= mag;
4764  }
4765  return *this;
4766  }
4767 
4768 
4769  Quaternion operator* (Quaternion const & in_right) const {
4770  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4771  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4772  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4773  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4774  }
4775 
4776  Quaternion operator* (float in_right) const {
4777  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4778  }
4779 
4780  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4781  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4782  }
4783 
4784  Quaternion operator/ (float in_right) const {
4785  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4786  }
4787 
4788  Quaternion operator- (Quaternion const & in_right) const {
4789  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4790  }
4791 
4792  Quaternion operator+ (Quaternion const & in_right) const {
4793  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4794  }
4795 
4796  inline float Norm() const {
4797  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4798  }
4799 
4800 
4801  Quaternion Log() const {
4802  Quaternion ret;
4803  float mag_q = Norm();
4804  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4805 
4806  ret.w = static_cast<float>(log(mag_q));
4807 
4808  if (mag_V > 0) {
4809  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4810 
4811  ret.x = x * scale;
4812  ret.y = y * scale;
4813  ret.z = z * scale;
4814  }
4815  else
4816  ret.x = ret.y = ret.z = 0;
4817 
4818  return ret;
4819  }
4820 
4821  Quaternion Exp() const {
4822  Quaternion ret;
4823  float ea = static_cast<float>(exp(w));
4824  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4825  float scale = ea * sin(mag_V) / mag_V;
4826 
4827  ret.w = ea * cos(mag_V);
4828  ret.x = scale * x;
4829  ret.y = scale * y;
4830  ret.z = scale * z;
4831 
4832  return ret;
4833  }
4834 
4835  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4836  Quaternion ret = *this + in_fraction * (in_right - *this);
4837  return ret.Normalize();
4838  }
4839 
4840 
4841  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4842  Quaternion q3;
4843  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4844 
4845  if (in_shortest_path_only && dot < 0) {
4846  dot = -dot;
4847  q3 = -1 * in_right;
4848  }
4849  else
4850  q3 = in_right;
4851 
4852  if (dot > -0.95f && dot < 0.95f) {
4853  float angle = static_cast<float>(acos(dot));
4854  float sina = static_cast<float>(sin(angle));
4855  float sinat = static_cast<float>(sin(angle*in_fraction));
4856  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4857 
4858  return (*this * sinaomt + q3 * sinat) / sina;
4859  }
4860  else //if the angle is small, we use linear interpolation
4861  return Lerp(q3, in_fraction);
4862  }
4863 
4864 
4865  /*
4866  Spherical cubic interpolation between two Quaternions
4867  \param in_right The Quaternion for interpolation.
4868  \param in_control1 The first control point.
4869  \param in_control2 The second control point.
4870  \param in_fraction Interpolation distance (0 - 1).
4871  \return Result of interpolation.
4872  */
4873  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4874  Quaternion q1 = Slerp(in_right , in_fraction, false);
4875  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4876 
4877  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4878  }
4879 
4886  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4887  Quaternion qni(w, -x, -y, -z);
4888 
4889  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4890  }
4891 
4892 };
4893 
4895 {
4898  size_t dot_dc_count;
4899  size_t dot_3d_count;
4900  size_t line_dc_count;
4901  size_t line_3d_count;
4914  size_t raster_count;
4915  size_t segment_count;
4922 };
4923 
4924 typedef unsigned char byte;
4925 typedef signed char sbyte;
4926 typedef intptr_t WindowHandle;
4927 typedef int64_t TouchID;
4928 typedef intptr_t PlatformData;
4929 typedef intptr_t OpaqueHandle;
4930 
4931 /*
4932 HPS Lexicon:
4933 
4934 Concept Class -- A class that contains only enums and possibly static functions. The
4935  constructor is usually private because they are not intended to be instantiated.
4936 
4937 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4938  database objects is subject to locking to prevent threading deadlocks. (2) The class
4939  of the same name, offering static functions to initiate operations that take place
4940  within the database.
4941 
4942 Key -- A reference counted smart pointer to an object in the database. The
4943 
4944 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4945  option group, or other type. Modifying a kit has no effect on the database unless
4946  and until it is applied. Kits should generally be passed by reference because they
4947  are potentially very large and copying them can be arduous.
4948 
4949 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4950  pointers should generally be passed by value to ensure the reference count is
4951  correct.
4952 
4953 User Space -- The external space occupied by all user code. User space objects are not
4954  in the database and are not subject to locking.
4955 
4956 */
4957 
4961 class SegmentKey;
4962 class AttributesControl;
4963 class LineKit;
4964 class LineKey;
4965 class TextKey;
4966 class TextKit;
4967 class Key;
4968 class VisibilityControl;
4969 class CameraControl;
4970 class SelectabilityControl;
4971 class TransparencyKit;
4972 class TransparencyControl;
4973 class CullingKit;
4974 class CullingControl;
4975 class GlyphKit;
4976 class ShapeKit;
4978 class GlyphDefinition;
4979 class ShapeDefinition;
4980 class GeometryInsertControl;
4981 class GlyphElement;
4982 class ShapeElement;
4983 class TextAttributeControl;
4984 class TextAttributeKit;
4985 class LineAttributeKit;
4986 class LineAttributeControl;
4987 class EdgeAttributeKit;
4988 class EdgeAttributeControl;
4989 class CurveAttributeKit;
4990 class CurveAttributeControl;
4991 class GlyphPoint;
4992 class MatrixKit;
4994 class TextureMatrixControl;
4995 class TextureDefinition;
4996 class MaterialMappingKit;
4998 class MaterialKit;
4999 class MarkerKit;
5000 class MarkerKey;
5001 class DistantLightKit;
5002 class DistantLightKey;
5003 class CuttingSectionKit;
5004 class CuttingSectionKey;
5007 class CylinderAttributeKit;
5009 class Cylinder;
5010 class CylinderKey;
5011 class CylinderKit;
5012 class SphereKey;
5013 class SphereKit;
5014 class SphereAttributeKit;
5016 class PolygonKit;
5017 class PolygonKey;
5018 class CircleKey;
5019 class CircleKit;
5020 class CircularArcKey;
5021 class CircularArcKit;
5022 class CircularWedgeKey;
5023 class CircularWedgeKit;
5024 class IncludeKey;
5025 class InfiniteLineKey;
5026 class InfiniteLineKit;
5027 class SpotlightKey;
5028 class SpotlightKit;
5029 class NURBSCurveKey;
5030 class NURBSCurveKit;
5031 class NURBSSurfaceKey;
5032 class NURBSSurfaceKit;
5033 class TrimKit;
5034 class TrimElement;
5035 class EllipseKey;
5036 class EllipseKit;
5037 class EllipticalArcKey;
5038 class EllipticalArcKit;
5039 class ShellKit;
5040 class ShellKey;
5041 class Shell;
5042 class MeshKit;
5043 class MeshKey;
5044 class WindowKey;
5045 class Database;
5048 class Driver;
5049 class Search;
5050 class PerformanceKit;
5051 class PerformanceControl;
5054 class DrawingAttributeKit;
5056 class PortfolioKey;
5057 class Selection;
5058 class SelectionOptionsKit;
5059 class SelectionResults;
5060 class SelectionItem;
5061 class SelectionControl;
5062 class HighlightControl;
5063 class HighlightOptionsKit;
5064 class ImageDefinition;
5065 class ImageKit;
5066 class TextureDefinition;
5067 class TextureOptionsKit;
5068 class NamedStyleDefinition;
5070 class GlyphDefinition;
5071 class LinePatternOptionsKit;
5072 class LinePatternDefinition;
5073 class LinePatternKit;
5074 class LinePatternElement;
5076 class CubeMapDefinition;
5077 class ShaderKit;
5078 class ShaderDefinition;
5079 class EmergencyHandler;
5080 class EventDispatcher;
5081 class EventHandler;
5082 class Event;
5083 class StandAloneWindowKey;
5085 class ApplicationWindowKey;
5087 class OffScreenWindowKey;
5090 class VisualEffectsControl;
5093 class ObjectPoint;
5094 class WorldPoint;
5095 class CameraPoint;
5096 class NormalizedPoint;
5097 class ScreenRangePoint;
5098 class InnerWindowPoint;
5099 class InnerPixelPoint;
5100 class WindowPoint;
5101 class PixelPoint;
5102 class VisibilityKit;
5103 class CameraKit;
5104 class SelectabilityKit;
5105 class MarkerAttributeKit;
5106 class LightingAttributeKit;
5107 class VisualEffectsKit;
5108 class PostProcessEffectsKit;
5109 class Portfolio;
5110 class SubwindowControl;
5111 class SubwindowKit;
5112 class World;
5113 class DebuggingControl;
5114 class DebuggingKit;
5115 class KeyPath;
5116 class ContourLineKit;
5117 class ContourLineControl;
5118 class UTF8;
5119 class StyleControl;
5120 class PortfolioControl;
5121 class ConditionalExpression;
5122 class ConditionControl;
5123 class WindowInfoKit;
5124 class WindowInfoControl;
5125 class FontInfoState;
5126 class FontInfoControl;
5127 class SearchOptionsKit;
5128 class AttributeLockControl;
5129 class AttributeLockKit;
5130 class ReferenceKey;
5131 class StyleKey;
5132 class BoundingKit;
5133 class BoundingControl;
5134 class TransformMaskKit;
5135 class TransformMaskControl;
5136 class ColorInterpolationKit;
5138 class UpdateOptionsKit;
5139 class UpdateOptionsControl;
5140 class GeometryKey;
5141 class TreeContext;
5144 class GridKit;
5145 class GridKey;
5148 
5152 
5153 
5156 class HPS_API GlyphPoint
5157 {
5158 public:
5159 
5161  GlyphPoint();
5162 
5167  GlyphPoint(sbyte in_x, sbyte in_y);
5168 
5173  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
5174 
5179  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
5180 
5185  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
5186 
5187  sbyte x;
5188  sbyte y;
5189 };
5190 
5193 enum class Type : uint32_t
5194 {
5195  None = 0x00000000,
5196  GenericMask = 0xffffff00,
5197 
5198  World = 0x00000001,
5199  UTF8 = 0x00000002,
5200  EventDispatcher = 0x00000003,
5201  EventHandler = 0x00000004,
5202  EventNotifier = 0x00000005,
5203  UpdateNotifier = 0x00000006,
5204  SearchResults = 0x00000008,
5205  FontSearchResults = 0x00000009,
5206  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
5207  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5208  SelectionResults = 0x0000000c,
5209  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5210  SelectionItem = 0x0000000e,
5211  TreeContext = 0x0000000f,
5212  StreamToolkit = 0x00000010,
5213  DriverEventHandler = 0x00000011,
5214 
5215  IONotifier = 0x04000100,
5216  StreamImportNotifier = 0x04000101,
5217  STLImportNotifier = 0x04000102,
5218  OBJImportNotifier = 0x04000103,
5219  ExchangeImportNotifier = 0x04000104,
5220  SketchupImportNotifier = 0x04000105,
5221  ParasolidImportNotifier = 0x04000106,
5222  ExchangeTranslationNotifier = 0x04000107,
5223  ExchangeExportNotifier = 0x04000108,
5224  StreamExportNotifier = 0x04000109,
5225  ExchangeReloadNotifier = 0x0400010a,
5226  DWGImportNotifier = 0x0400010b,
5227  ExchangeParasolidImportNotifier = 0x0400010c,
5228  PointCloudImportNotifier = 0x0400010d,
5229  OOCImportNotifier = 0x0400010e,
5230 
5231  Kit = 0x01000000,
5232  MarkerKit = 0x01000010,
5233  SphereAttributeKit = 0x01000011,
5234  TextAttributeKit = 0x01000012,
5235  TransparencyKit = 0x01000013,
5236  VisibilityKit = 0x01000014,
5237  VisualEffectsKit = 0x01000015,
5238  CuttingSectionAttributeKit = 0x01000016,
5239  CircleKit = 0x01000017,
5240  CircularArcKit = 0x01000018,
5241  CircularWedgeKit = 0x01000019,
5242  CuttingSectionKit = 0x0100001a,
5243  CylinderKit = 0x0100001b,
5244  DistantLightKit = 0x0100001c,
5245  EllipseKit = 0x0100001d,
5246  EllipticalArcKit = 0x0100001e,
5247  InfiniteLineKit = 0x0100001f,
5248  LineKit = 0x01000020,
5249  NURBSCurveKit = 0x01000021,
5250  MeshKit = 0x01000022,
5251  NURBSSurfaceKit = 0x01000023,
5252  PolygonKit = 0x01000024,
5253  SphereKit = 0x01000025,
5254  SpotlightKit = 0x01000026,
5255  ShellKit = 0x01000027,
5256  TextKit = 0x01000028,
5257  MaterialKit = 0x01000029,
5258  TrimKit = 0x0100002a,
5259  TextureOptionsKit = 0x0100002c,
5260  LinePatternKit = 0x0100002d,
5261  GlyphKit = 0x0100002e,
5262  ImageKit = 0x0100002f,
5263  LinePatternOptionsKit = 0x01000030,
5264  CameraKit = 0x01000031,
5265  BoundingKit = 0x01000032,
5266  CullingKit = 0x01000033,
5267  CurveAttributeKit = 0x01000034,
5268  CylinderAttributeKit = 0x01000035,
5269  EdgeAttributeKit = 0x01000036,
5270  LightingAttributeKit = 0x01000037,
5271  LineAttributeKit = 0x01000038,
5272  MarkerAttributeKit = 0x01000039,
5273  MaterialMappingKit = 0x0100003a,
5274  MatrixKit = 0x0100003b,
5275  NURBSSurfaceAttributeKit = 0x0100003c,
5276  PostProcessEffectsKit = 0x0100003d,
5277  SelectabilityKit = 0x0100003e,
5278  SelectionOptionsKit = 0x0100003f,
5279  StandAloneWindowOptionsKit = 0x01000040,
5280  OffScreenWindowOptionsKit = 0x01000041,
5281  ApplicationWindowOptionsKit = 0x01000042,
5282  HighlightOptionsKit = 0x01000043,
5283  LinePatternParallelKit = 0x01000044,
5284  SubwindowKit = 0x01000045,
5285  PerformanceKit = 0x01000046,
5286  HiddenLineAttributeKit = 0x01000047,
5287  DrawingAttributeKit = 0x01000048,
5288  ShaderKit = 0x01000049,
5289  DebuggingKit = 0x0100004a,
5290  ContourLineKit = 0x0100004b,
5291  StreamImportOptionsKit = 0x0100004c,
5292  StreamImportResultsKit = 0x0100004d,
5293  StreamExportOptionsKit = 0x0100004e,
5294  StreamExportResultsKit = 0x0100004f,
5295  WindowInfoKit = 0x01000050,
5296  ImageImportOptionsKit = 0x01000051,
5297  SearchOptionsKit = 0x01000052,
5298  ShaderImportOptionsKit = 0x01000053,
5299  HardcopyExportOptionsKit = 0x01000055,
5300  AttributeLockKit = 0x01000056,
5301  TransformMaskKit = 0x01000057,
5302  ColorInterpolationKit = 0x01000058,
5303  UpdateOptionsKit = 0x01000059,
5304  ImageExportOptionsKit = 0x0100005a,
5305  OBJImportOptionsKit = 0x0100005b,
5306  OBJImportResultsKit = 0x0100005c,
5307  STLImportOptionsKit = 0x0100005d,
5308  STLImportResultsKit = 0x0100005e,
5309  ShellOptimizationOptionsKit = 0x0100005f,
5310  ShellRelationOptionsKit = 0x01000060,
5311  ShellRelationResultsKit = 0x01000061,
5312  GridKit = 0x01000062,
5313  CutGeometryGatheringOptionsKit = 0x01000063,
5314  SegmentOptimizationOptionsKit = 0x01000064,
5315  PointCloudImportOptionsKit = 0x01000065,
5316  PointCloudImportResultsKit = 0x01000066,
5317  ShapeKit = 0x01000067,
5318  HardcopyGDIExportOptionsKit = 0x01000068,
5319 
5320  LinePatternElement = 0x03000000,
5321  SolidLinePatternElement = 0x03000001,
5322  BlankLinePatternElement = 0x03000002,
5323  GlyphLinePatternElement = 0x03000003,
5324 
5325  GlyphElement = 0x05000000,
5326  DotGlyphElement = 0x05000001,
5327  LineGlyphElement = 0x05000002,
5328  EllipseGlyphElement = 0x05000003,
5329  CircularArcGlyphElement = 0x05000004,
5330  InfiniteLineGlyphElement = 0x05000005,
5331  SphereGlyphElement = 0x05000006,
5332 
5333  TrimElement = 0x07000000,
5334 
5335  ConditionalExpression = 0x09000000,
5336  NOTCondition = 0x09000001,
5337  ANDCondition = 0x09000002,
5338  ORCondition = 0x09000003,
5339  XORCondition = 0x09000004,
5340  EQCondition = 0x09000005,
5341  NEQCondition = 0x09000006,
5342  GTCondition = 0x09000007,
5343  LTCondition = 0x09000008,
5344  GTEQCondition = 0x09000009,
5345  LTEQCondition = 0x0900000A,
5346 
5347  ShapeElement = 0x0B000000,
5348  PolygonShapeElement = 0x0B000001,
5349  EllipseShapeElement = 0x0B000002,
5350  CircleShapeElement = 0x0B000003,
5351  EllipticalArcShapeElement = 0x0B000004,
5352  AnchorShapeElement = 0x0B000005,
5353  LineShapeElement = 0x0B000006,
5354  CircularArcShapeElement = 0x0B000007,
5355 
5356  MouseState = 0x01001001,
5357  TouchState = 0x01001002,
5358  KeyboardState = 0x01001003,
5359  FontInfoState = 0x01001004,
5360 
5361  KeyPath = 0x01000F01,
5362 
5363  Key = 0x10000000,
5364  IncludeKey = 0x10000001,
5365  PortfolioKey = 0x10000002,
5366  StyleKey = 0x10000003,
5367 
5368  SegmentKey = 0x10200000,
5369  WindowKey = 0x10600000,
5370  StandAloneWindowKey = 0x10600001,
5371  OffScreenWindowKey = 0x10600002,
5372  ApplicationWindowKey = 0x10600003,
5373 
5374  GeometryKey = 0x10100000,
5375  ReferenceKey = 0x10100001,
5376  CircleKey = 0x10100002,
5377  CircularArcKey = 0x10100003,
5378  CircularWedgeKey = 0x10100004,
5379  CuttingSectionKey = 0x10100005,
5380  CylinderKey = 0x10100006,
5381  EllipseKey = 0x10100007,
5382  EllipticalArcKey = 0x10100008,
5383  InfiniteLineKey = 0x10100009,
5384  LineKey = 0x1010000a,
5385  DistantLightKey = 0x1010000b,
5386  SpotlightKey = 0x1010000c,
5387  MarkerKey = 0x1010000d,
5388  MeshKey = 0x1010000e,
5389  NURBSCurveKey = 0x1010000f,
5390  NURBSSurfaceKey = 0x10100010,
5391  PolygonKey = 0x10100011,
5392  ShellKey = 0x10100012,
5393  SphereKey = 0x10100013,
5394  TextKey = 0x10100014,
5395  GridKey = 0x10100015,
5396 
5397  Definition = 0x20000000,
5398  NamedStyleDefinition = 0x20000001,
5399  TextureDefinition = 0x20000002,
5400  LinePatternDefinition = 0x20000003,
5401  GlyphDefinition = 0x20000004,
5402  CubeMapDefinition = 0x20000005,
5403  ImageDefinition = 0x20000006,
5404  MaterialPaletteDefinition = 0x20000007,
5405  ShaderDefinition = 0x20000008,
5406  ShapeDefinition = 0x20000009,
5407 
5408  Control = 0x50000000,
5409  CameraControl = 0x50000001,
5410  SelectabilityControl = 0x50000002,
5411  MarkerAttributeControl = 0x50000003,
5412  SphereAttributeControl = 0x50000004,
5413  LightingAttributeControl = 0x50000005,
5414  CylinderAttributeControl = 0x50000006,
5415  TextAttributeControl = 0x50000007,
5416  LineAttributeControl = 0x50000008,
5417  EdgeAttributeControl = 0x50000009,
5418  CurveAttributeControl = 0x5000000a,
5419  ModellingMatrixControl = 0x5000000b,
5420  TextureMatrixControl = 0x5000000c,
5421  CullingControl = 0x5000000d,
5422  TransparencyControl = 0x5000000e,
5423  MaterialMappingControl = 0x5000000f,
5424  NURBSSurfaceAttributeControl = 0x50000010,
5425  PostProcessEffectsControl = 0x50000011,
5426  BoundingControl = 0x50000012,
5427  VisualEffectsControl = 0x50000013,
5428  SelectionOptionsControl = 0x50000014,
5429  HighlightOptionsControl = 0x50000015,
5430  DefinitionControl = 0x50000016,
5431  SelectionControl = 0x50000017,
5432  HighlightControl = 0x50000018,
5433  StandAloneWindowOptionsControl = 0x50000019,
5434  OffScreenWindowOptionsControl = 0x5000001a,
5435  ApplicationWindowOptionsControl = 0x5000001b,
5436  VisibilityControl = 0x5000001c,
5437  SubwindowControl = 0x5000001d,
5438  PerformanceControl = 0x5000001e,
5439  HiddenLineAttributeControl = 0x5000001f,
5440  DrawingAttributeControl = 0x50000020,
5441  DebuggingControl = 0x50000021,
5442  ContourLineControl = 0x50000022,
5443  StyleControl = 0x50000023,
5444  ConditionControl = 0x50000024,
5445  PortfolioControl = 0x50000025,
5446  WindowInfoControl = 0x50000026,
5447  AttributeLockControl = 0x50000027,
5448  TransformMaskControl = 0x50000028,
5449  ColorInterpolationControl = 0x50000029,
5450  UpdateOptionsControl = 0x50000030,
5451  CuttingSectionAttributeControl = 0x50000031,
5452 
5453  LibraryMask = 0x80FF0000,
5454 
5455  Sprocket = 0x80000000,
5456  Canvas = 0x80000001,
5457  Layout = 0x80000002,
5458  View = 0x80000003,
5459  Model = 0x80000004,
5460  Operator = 0x80000005,
5461  SprocketPath = 0x80000007,
5462 
5463  SprocketControl = 0xD0000000,
5464  OperatorControl = 0xD0000008,
5465  NavigationCubeControl = 0xD0000009,
5466  AxisTriadControl = 0xD000000A,
5467 
5468  SprocketKit = 0x81000000,
5469 
5470  Metadata = 0x80001000,
5471  IntegerMetadata = 0x80001001,
5472  UnsignedIntegerMetadata = 0x80001002,
5473  DoubleMetadata = 0x80001003,
5474  StringMetadata = 0x80001004,
5475  TimeMetadata = 0x80001005,
5476  BooleanMetadata = 0x80001006,
5477 
5478  Component = 0x80000200,
5479  Filter = 0x80000600,
5480  Capture = 0x80000a00,
5481  CADModel = 0x80000300,
5482  ComponentPath = 0x81001000,
5483 
5484  ExchangeMask = 0x80020000,
5485  ExchangeComponent = 0x80021200,
5486  ExchangeSheet = 0x80021201,
5487  ExchangeProductOccurrence = 0x80021202,
5488  ExchangeFilter = 0x80020601,
5489  ExchangeCapture = 0x80020a01,
5490  ExchangeCADModel = 0x80020301,
5491  ExchangeConfiguration = 0x81020001,
5492  ExchangeImportOptionsKit = 0x81020002,
5493  ExchangeExportACISOptionsKit = 0x81020003,
5494  ExchangeExportIGESOptionsKit = 0x81020004,
5495  ExchangeExportJTOptionsKit = 0x81020005,
5496  ExchangeExportParasolidOptionsKit = 0x81020006,
5497  ExchangeExportPRCOptionsKit = 0x81020007,
5498  ExchangeExportSTEPOptionsKit = 0x81020008,
5499  ExchangeExportSTLOptionsKit = 0x81020009,
5500  ExchangeExportU3DOptionsKit = 0x8102000a,
5501  ExchangeExportXMLOptionsKit = 0x8102000b,
5502  ExchangeTessellationOptionsKit = 0x8102000c,
5503  ExchangeModelFileImportOptionsKit = 0x8102000d,
5504  ExchangeTranslationOptionsKit = 0x8102000e,
5505  ExchangeNURBSConversionOptionsKit = 0x8102000f,
5506  ExchangeExport3MFOptionsKit = 0x81020010,
5507 
5508  PublishMask = 0x80040000,
5509  PublishDocumentKit = 0x81040001,
5510  PublishPageKit = 0x81040002,
5511  PublishTemplateKit = 0x81040003,
5512  PublishAnnotationKit = 0x81040004,
5513  PublishArtworkKit = 0x81040005,
5514  PublishViewKit = 0x81040006,
5515  PublishTextKit = 0x81040007,
5516  PublishImageKit = 0x81040008,
5517  PublishTableKit = 0x81040009,
5518  PublishExportOptionsKit = 0x8104000a,
5519  PublishLinkKit = 0x8104000b,
5520  PublishButtonKit = 0x8104000c,
5521  PublishTextFieldKit = 0x8104000d,
5522  PublishSlideTableKit = 0x8104000e,
5523  PublishCheckBoxKit = 0x8104000f,
5524  PublishRadioButtonKit = 0x81040010,
5525  PublishListBoxKit = 0x81040011,
5526  PublishDropDownListKit = 0x81040012,
5527  PublishSignatureFieldKit = 0x81040013,
5528 
5529  PublishDocumentKey = 0x80040001,
5530  PublishPageControl = 0x80040002,
5531 
5532  ExchangeParasolidMask = 0x80080000,
5533 
5534  SceneTree = 0x80008001,
5535  SceneTreeItem = 0x80008002,
5536 
5537  ComponentTree = 0x80008003,
5538  ComponentTreeItem = 0x80008004,
5539 
5540  SketchupMask = 0x80100000,
5541  SketchupImportOptionsKit = 0x81100001,
5542  SketchupImportResultsKit = 0x81100002,
5543 
5544  ParasolidMask = 0x80200000,
5545  ParasolidComponent = 0x80201201,
5546  ParasolidCADModel = 0x80200302,
5547  ParasolidImportOptionsKit = 0x81200003,
5548  ParasolidFacetTessellationKit = 0x81200004,
5549  ParasolidLineTessellationKit = 0x81200005,
5550  ParasolidExportOptionsKit = 0x81200006,
5551 
5552  DWGMask = 0x80400000,
5553  DWGComponent = 0x80401201,
5554  DWGLayer = 0x80401202,
5555  DWGLayout = 0x80400a03,
5556  DWGCADModel = 0x80400304,
5557  DWGImportOptionsKit = 0x81400005,
5558 
5559  OOCMask = 0x80800000,
5560  OOCImportOptionsKit = 0x81800001,
5561  OOCImportResultsKit = 0x81800002,
5562 
5563  HTMLMask = 0x80010000,
5564 
5565 
5566  IONotifierData = 0x84000200,
5567  StreamImportNotifierData = 0x84000201,
5568  STLImportNotifierData = 0x84000202,
5569  OBJImportNotifierData = 0x84000203,
5570  ExchangeImportNotifierData = 0x84020204,
5571  SketchupImportNotifierData = 0x84100205,
5572  ParasolidImportNotifierData = 0x84200206,
5573  ExchangeTranslationNotifierData = 0x84020207,
5574  ExchangeExportNotifierData = 0x84020208,
5575  StreamExportNotifierData = 0x84000209,
5576  DWGImportNotifierData = 0x8440020a,
5577  ExchangeParasolidImportNotifierData = 0x8408020b,
5578  PointCloudImportNotifierData = 0x8400020c,
5579  OOCImportNotifierData = 0x8480020d,
5580 };
5581 
5583 class HPS_API Memory
5584 {
5585 public:
5591  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5592 
5593 
5598  static void Free(void * in_pointer);
5599 
5600 private:
5602  Memory();
5603 };
5604 
5605 
5607 template <typename T>
5608 class NO_HPS_API Allocator
5609 {
5610 public:
5611  typedef T value_type;
5612  typedef value_type * pointer;
5613  typedef value_type const * const_pointer;
5614  typedef value_type & reference;
5615  typedef value_type const & const_reference;
5616  typedef size_t size_type;
5617  typedef ptrdiff_t difference_type;
5618 
5619 
5620  Allocator() {}
5621  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5622  ~Allocator() {}
5623 
5624  template <typename U> Allocator(Allocator<U> const &) {}
5625 
5626  template <typename U>
5627  struct rebind
5628  {
5629  typedef Allocator<U> other;
5630  };
5631 
5632 
5633  pointer address(reference x) const { return &x; }
5634  const_pointer address(const_reference x) const { return &x; }
5635 
5636  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5637  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5638 
5639 #if defined(_MSC_VER) || defined (__APPLE__)
5640  void construct(pointer p, const_reference x) { new(p) T(x); }
5641  void construct(pointer p, value_type && x) { new(p) T(std::move(x)); }
5642 #else
5643  template<typename U, typename... Args>
5644  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5645 #endif
5646  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5647 
5648  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5649 };
5650 
5651 template <typename T, typename U>
5652 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5653 
5654 template <typename T, typename U>
5655 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5656 
5658 class Exception : public std::runtime_error
5659 {
5660 public:
5661  Exception(char const * in_info) : std::runtime_error(in_info) { }
5662 };
5663 
5664 
5667 {
5668 public:
5669  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5670  Exception(in_info) {}
5671 };
5672 
5673 
5677 {
5678 public:
5679  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5680  Exception(in_info) {}
5681 };
5682 
5683 
5686 {
5687 public:
5688  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5689  Exception(in_info) {}
5690 };
5691 
5692 
5695 {
5696 public:
5697  InvalidLicenseException(char const * in_info) :
5698  Exception(in_info) {}
5699 };
5700 
5701 
5704 {
5705 public:
5706  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5707  Exception(in_info) {}
5708 };
5709 
5711 class IOException : public Exception
5712 {
5713 public:
5717  IOException(char const * in_info, IOResult in_result)
5718  : Exception(in_info), result(in_result) {}
5719 
5720  IOResult result;
5721 };
5722 
5723 
5725 class HPS_API Object
5726 {
5727 public:
5728 
5729  Object();
5730 
5731  Object(Object const & that);
5732 
5733  virtual ~Object();
5734 
5735  Object & operator=(Object const & other_object);
5736 
5740  Object(Object && in_that);
5741 
5742 
5746  Object & operator=(Object && in_that);
5747 
5751  virtual HPS::Type Type() const;
5752 
5756  virtual HPS::Type ObjectType() const { return HPS::Type::None; }
5757 
5760  virtual bool Empty() const {return (impl_ == 0);};
5761 
5763  virtual void Reset();
5764 
5768  bool HasType(HPS::Type in_mask) const;
5769 
5772  intptr_t GetClassID() const;
5773 
5777  intptr_t GetInstanceID() const;
5778 
5781  template <typename T>
5782  static intptr_t ClassID()
5783  {
5784  static const intptr_t ret = T().GetClassID();
5785  return ret;
5786  }
5787 private:
5788 
5789  friend class HPSI::Impl;
5790  friend class HPSI::KeyImpl;
5791  friend class HPSI::TicketImpl;
5792 
5793  HPSI::Impl * impl_;
5794 };
5795 
5796 
5798 class HPS_API Control : public Object
5799 {
5800 public:
5801  virtual HPS::Type Type() const { return ObjectType(); }
5802  HPS::Type ObjectType() const { return HPS::Type::Control; }
5803 
5804 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5805  Control(Control const & in_that) = default;
5806 #endif
5807 
5808 protected:
5809  Control() {}
5810 
5814  Control(Control && in_that) : Object(std::move(in_that)) {}
5815 
5819  Control & operator=(Control && in_that)
5820  {
5821  this->Object::operator=(std::move(in_that));
5822  return *this;
5823  }
5824 };
5825 
5826 
5828 class HPS_API Kit : public Object
5829 {
5830 public:
5831  HPS::Type ObjectType() const { return HPS::Type::Kit; }
5832  virtual HPS::Type Type() const { return ObjectType(); }
5833 
5834 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5835  Kit(Kit const & in_that) = default;
5836 #endif
5837 
5838 protected:
5839  Kit() {}
5840 
5844  Kit(Kit && in_that) : Object(std::move(in_that)) {}
5845 
5849  Kit & operator=(Kit && in_that)
5850  {
5851  this->Object::operator=(std::move(in_that));
5852  return *this;
5853  }
5854 };
5855 
5856 
5858 class HPS_API ObjectPoint : public Point
5859 {
5860 public:
5861 
5863  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5864 
5866  ObjectPoint(Point const & in_point):Point(in_point){}
5867 
5869  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5870 
5872  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5873 
5875  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5876 
5878  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5879 
5881  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5882 
5884  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5885 
5887  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5888 
5890  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5891 
5893  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5894 
5895 private:
5896 
5897  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5898  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5899  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5900  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5901  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5902  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5903  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5904  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5905 
5906 };
5907 
5909 class HPS_API WorldPoint : public Point
5910 {
5911 public:
5913  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5914 
5916  WorldPoint(Point const & in_point):Point(in_point){}
5917 
5919  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5920 
5922  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5923 
5925  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5926 
5928  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5929 
5931  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5932 
5934  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5935 
5937  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5938 
5940  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5941 
5943  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5944 
5945 private:
5946 
5947  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5948  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5949  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5950  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5951  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5952  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5953  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5954  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5955 
5956 };
5957 
5959 class HPS_API CameraPoint : public Point
5960 {
5961 public:
5963  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5964 
5966  CameraPoint(Point const & in_point):Point(in_point){}
5967 
5969  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5970 
5972  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5973 
5975  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5976 
5978  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5979 
5981  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5982 
5984  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5985 
5987  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5988 
5990  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5991 
5993  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5994 
5995 private:
5996  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5997  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5998  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5999  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6000  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6001  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6002  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6003  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6004 
6005 };
6006 
6008 class HPS_API NormalizedPoint : public Point
6009 {
6010 public:
6011 
6013  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6014 
6016  NormalizedPoint(Point const & in_point):Point(in_point){}
6017 
6019  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6020 
6022  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
6023 
6025  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
6026 
6028  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6029 
6031  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6032 
6034  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6035 
6037  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6038 
6040  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
6041 
6043  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
6044 
6045 private:
6046  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6047  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6048  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6049  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6050  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6051  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6052  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6053  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6054 };
6055 
6057 class HPS_API ScreenRangePoint : public Point
6058 {
6059 public:
6061  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6062 
6064  ScreenRangePoint(Point const & in_point):Point(in_point){}
6065 
6067  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
6068 
6070  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
6071 
6073  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
6074 
6076  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6077 
6079  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6080 
6082  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6083 
6085  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6086 
6088  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
6089 
6091  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
6092 
6093 private:
6094  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6095  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6096  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6097  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6098  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6099  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6100  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6101  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6102 
6103 };
6104 
6106 class HPS_API InnerWindowPoint : public Point
6107 {
6108 public:
6109 
6111  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6112 
6114  InnerWindowPoint(Point const & in_point):Point(in_point){}
6115 
6117  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6118 
6120  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6121 
6123  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6124 
6126  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6127 
6129  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6130 
6132  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6133 
6135  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6136 
6138  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6139 
6141  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6142 
6143 private:
6144  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6145  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6146  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6147  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6148  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6149  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6150  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6151  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6152 };
6153 
6155 class HPS_API InnerPixelPoint : public Point
6156 {
6157 public:
6158 
6160  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6161 
6163  InnerPixelPoint(Point const & in_point):Point(in_point){}
6164 
6166  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6167 
6169  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6170 
6172  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6173 
6175  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6176 
6178  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6179 
6181  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6182 
6184  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6185 
6187  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6188 
6190  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6191 
6192 private:
6193  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6194  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6195  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6196  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6197  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6198  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6199  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6200  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6201 
6202 };
6203 
6205 class HPS_API WindowPoint : public Point
6206 {
6207 public:
6208 
6210  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6211 
6213  WindowPoint(Point const & in_point):Point(in_point){}
6214 
6216  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6217 
6219  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
6220 
6222  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
6223 
6225  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6226 
6228  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6229 
6231  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6232 
6234  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6235 
6237  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
6238 
6240  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
6241 
6242 private:
6243  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6244  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6245  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6246  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6247  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6248  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6249  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6250  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
6251 };
6252 
6253 
6255 class HPS_API PixelPoint : public Point
6256 {
6257 public:
6259  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
6260 
6262  PixelPoint(Point const & in_point):Point(in_point){}
6263 
6265  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
6266 
6268  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
6269 
6271  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
6272 
6274  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
6275 
6277  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
6278 
6280  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
6281 
6283  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
6284 
6286  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
6287 
6289  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
6290 
6291 private:
6292  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
6293  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
6294  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
6295  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
6296  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
6297  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
6298  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
6299  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
6300 
6301 };
6302 
6305 class HPS_API Event
6306 {
6307 public:
6311  enum class Status : uint32_t
6312  {
6313  InProgress,
6314  Completed,
6315  Failed
6316  };
6317 
6319  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6320 
6321  virtual ~Event();
6322 
6324  intptr_t GetClassID() const;
6325 
6328  virtual Event * Clone() const=0;
6329 
6331  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6332 
6335  virtual intptr_t Freshen() const { return 0; }
6336 
6338  intptr_t GetChannel() const { return channel; }
6339 
6341  Time GetTimeStamp() const { return time_stamp; }
6342 
6344  bool IsConsumable() const { return consumable; }
6345 
6346  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6347  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6348 
6349 protected:
6350  intptr_t channel;
6351  bool consumable;
6352 
6353 private:
6354  friend class HPSI::EventDispatcherImpl;
6355  Time time_stamp;
6356 };
6357 
6358 
6361 class HPS_API EventNotifier : public Object
6362 {
6363 public:
6364 
6366  EventNotifier();
6367 
6370  EventNotifier(EventNotifier const & in_that);
6371 
6375  EventNotifier(EventNotifier && in_that);
6376 
6380  EventNotifier & operator=(EventNotifier && in_that);
6381 
6382  virtual ~EventNotifier();
6383 
6384  HPS::Type ObjectType() const {return HPS::Type::EventNotifier;};
6385 
6389  EventNotifier & operator=(EventNotifier const & in_that);
6390 
6393  virtual void Assign(EventNotifier const & in_that);
6394 
6396  void Wait() const;
6397 
6400  Event::Status Status() const;
6401 };
6402 
6404 enum class KeyboardCode : uint32_t
6405 {
6406  None = 0,
6407 
6408  Backspace = 8,
6409  Tab = 9,
6410  Clear = 11,
6411  Return = 13,
6412  Shift = 16,
6413  Control = 17,
6414  Alt = 18,
6415  Pause = 19,
6416  Escape = 27,
6417 
6418  Space = 32,
6419  ExclamationMark,
6420  DoubleQuote,
6421  Number,
6422  Dollar,
6423  Percent,
6424  Ampersand,
6425  SingleQuote,
6426  OpenParen,
6427  CloseParen,
6428 
6429  Asterisk,
6430  Plus,
6431  Comma,
6432  Hyphen,
6433  Period,
6434  Slash,
6435 
6436  D0,
6437  D1,
6438  D2,
6439  D3,
6440  D4,
6441  D5,
6442  D6,
6443  D7,
6444  D8,
6445  D9,
6446 
6447  Colon,
6448  Semicolon,
6449  LessThan,
6450  Equal,
6451  GreaterThan,
6452  QuestionMark,
6453  AtSymbol,
6454 
6455  A,
6456  B,
6457  C,
6458  D,
6459  E,
6460  F,
6461  G,
6462  H,
6463  I,
6464  J,
6465  K,
6466  L,
6467  M,
6468  N,
6469  O,
6470  P,
6471  Q,
6472  R,
6473  S,
6474  T,
6475  U,
6476  V,
6477  W,
6478  X,
6479  Y,
6480  Z,
6481 
6482  OpenBrackets,
6483  Backslash,
6484  CloseBrackets,
6485  Caret,
6486  Underscore,
6487  Backtick,
6488 
6489  a,
6490  b,
6491  c,
6492  d,
6493  e,
6494  f,
6495  g,
6496  h,
6497  i,
6498  j,
6499  k,
6500  l,
6501  m,
6502  n,
6503  o,
6504  p,
6505  q,
6506  r,
6507  s,
6508  t,
6509  u,
6510  v,
6511  w,
6512  x,
6513  y,
6514  z,
6515 
6516  OpenBrace,
6517  VerticalBar,
6518  ClosingBrace,
6519  Tilde,
6520  Delete,
6521 
6522  Insert=1024,
6523  Home,
6524  End,
6525  PageUp,
6526  PageDown,
6527 
6528  Help,
6529 
6530  Left,
6531  Up,
6532  Right,
6533  Down,
6534 
6535  NumPad0,
6536  NumPad1,
6537  NumPad2,
6538  NumPad3,
6539  NumPad4,
6540  NumPad5,
6541  NumPad6,
6542  NumPad7,
6543  NumPad8,
6544  NumPad9,
6545 
6546  F1,
6547  F2,
6548  F3,
6549  F4,
6550  F5,
6551  F6,
6552  F7,
6553  F8,
6554  F9,
6555  F10,
6556  F11,
6557  F12,
6558  F13,
6559  F14,
6560  F15,
6561  F16,
6562  F17,
6563  F18,
6564  F19,
6565  F20,
6566  F21,
6567  F22,
6568  F23,
6569  F24,
6570 
6571  CapsLock,
6572  NumLock,
6573  ScrollLock,
6574  LeftShift,
6575  RightShift,
6576  LeftCtrl,
6577  RightCtrl,
6578  LeftAlt,
6579  RightAlt,
6580 
6581  Select,
6582  Print,
6583  Execute,
6584  PrintScreen,
6585 };
6586 
6587 
6589 class NO_HPS_API Touch
6590 {
6591 public:
6592 
6595  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6596 
6601  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6602  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6603 
6607  inline bool operator==(Touch const & in_that) const
6608  {
6609  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6610  }
6611 
6615  inline bool operator!=(Touch const & in_that) const
6616  {
6617  return !(*this == in_that);
6618  }
6619 
6620  TouchID ID;
6622  size_t TapCount;
6623 };
6624 
6625 
6626 typedef std::vector<Point, Allocator<Point> > PointArray;
6627 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6628 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6629 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6630 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6631 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6632 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6633 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6634 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6635 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6636 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6637 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6638 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6639 typedef std::vector<int, Allocator<int> > IntArray;
6640 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6641 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6642 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6643 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6644 typedef std::vector<float, Allocator<float> > FloatArray;
6645 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6646 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6647 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6648 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6649 typedef std::vector<ShapeElement, Allocator<ShapeElement> > ShapeElementArray;
6650 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6651 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6652 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6653 typedef std::vector<bool, Allocator<bool> > BoolArray;
6654 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6655 typedef std::vector<Key, Allocator<Key> > KeyArray;
6656 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6657 typedef std::vector<char, Allocator<char> > CharArray;
6658 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6659 typedef std::vector<byte, Allocator<byte> > ByteArray;
6660 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6661 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6662 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6663 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6664 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6665 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6666 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6667 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6668 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6669 typedef std::vector<ConditionalExpression, Allocator<ConditionalExpression> > ConditionalExpressionArray;
6670 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6671 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6672 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6673 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6674 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6675 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6676 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6677 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6678 typedef std::vector<ShapeDefinition, Allocator<ShapeDefinition> > ShapeDefinitionArray;
6679 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6680 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6681 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6682 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6683 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6684 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6685 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6686 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6687 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6688 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6689 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6690 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6691 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6692 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6693 typedef std::vector<Text::MarginUnits, Allocator<Text::MarginUnits> > TextMarginUnitsArray;
6694 typedef std::vector<PointArrayArray, Allocator<PointArrayArray> > PointArrayArrayArray;
6695 typedef std::vector<Drawing::ClipSpace, Allocator<Drawing::ClipSpace> > ClipSpaceArray;
6696 typedef std::vector<Drawing::ClipOperation, Allocator<Drawing::ClipOperation> > ClipOperationArray;
6697 typedef std::vector<MatrixKit, Allocator<MatrixKit> > MatrixKitArray;
6698 typedef std::vector<int32_t, HPS::Allocator<int32_t>> Int32Array; // used by OOC
6699 
6703 class HPS_API ShapeCoordinate
6704 {
6705 public:
6707  ShapeCoordinate();
6708 
6712  ShapeCoordinate(float in_x, float in_y);
6713 
6718  ShapeCoordinate(float in_x, float in_y, FloatArray const & in_margins);
6719 
6725  ShapeCoordinate(float in_x, float in_y, size_t in_count, float const in_margins []);
6726 
6731  ShapeCoordinate(float in_x, float in_y, float in_radius);
6732 
6738  ShapeCoordinate(float in_x, float in_y, float in_radius, FloatArray const & in_margins);
6739 
6746  ShapeCoordinate(float in_x, float in_y, float in_radius, size_t in_count, float const in_margins []);
6747 
6751  bool Equals(ShapeCoordinate const & in_that) const;
6752 
6756  bool operator==(ShapeCoordinate const & in_that) const { return Equals(in_that); }
6757 
6761  bool operator!=(ShapeCoordinate const & in_that) const { return !Equals(in_that); }
6762 
6769  ShapeCoordinate & SetMargins(float in_margin_one, float in_margin_two = 0.0f, float in_margin_three = 0.0f, float in_margin_four = 0.0f);
6770 
6774  bool ShowMargins(FloatArray & out_margins) const;
6775 
6778  ShapeCoordinate & UnsetMargins();
6779 
6780  float x;
6781  float y;
6782  float radius;
6783  FloatArray margins;
6784 };
6785 
6788 class HPS_API ShapePoint
6789 {
6790 public:
6792  ShapePoint();
6793 
6797  ShapePoint(ShapeCoordinate const & in_x, ShapeCoordinate const & in_y);
6798 
6805  ShapePoint(float in_x, float in_y);
6806 
6810  bool Equals(ShapePoint const & in_that) const { return (x == in_that.x && y == in_that.y); }
6811 
6815  bool operator==(ShapePoint const & in_that) const { return Equals(in_that); }
6816 
6820  bool operator!=(ShapePoint const & in_that) const { return !Equals(in_that); }
6821 
6822  ShapeCoordinate x;
6823  ShapeCoordinate y;
6824 };
6825 
6826 typedef std::vector<ShapePoint, Allocator<ShapePoint> > ShapePointArray;
6827 
6829 class HPS_API SearchResultsIterator : public Object
6830 {
6831 public:
6832 
6835 
6839  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6840 
6845 
6849  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6850 
6852 
6853  HPS::Type ObjectType() const {return HPS::Type::SearchResultsIterator;}
6854 
6859  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6860 
6865  void Set(SearchResultsIterator const & in_search_results_iterator);
6866 
6868  void Next();
6869 
6872  SearchResultsIterator & operator++();
6873 
6876  SearchResultsIterator operator++(int in_val);
6877 
6880  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6881 
6884  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6885 
6889  bool IsValid() const;
6890 
6892  void Reset();
6893 
6897  Key GetItem() const;
6898 
6901  Key operator*() const;
6902 
6905  SearchTypeArray GetResultTypes() const;
6906 };
6907 
6909 class HPS_API SearchResults : public Object
6910 {
6911 public:
6913  SearchResults();
6914 
6917  SearchResults(SearchResults const & in_search_results);
6918 
6922  SearchResults(SearchResults && in_that);
6923 
6927  SearchResults & operator=(SearchResults && in_that);
6928 
6930  virtual void Reset();
6931 
6933  ~SearchResults();
6934 
6935  HPS::Type ObjectType() const {return HPS::Type::SearchResults;}
6936 
6940  void Assign(SearchResults const & in_search_results);
6941 
6945  SearchResults & operator=(SearchResults const & in_search_results);
6946 
6949  size_t GetCount() const;
6950 
6953  SearchResultsIterator GetIterator() const;
6954 };
6955 
6957 class HPS_API FontSearchResultsIterator : public Object
6958 {
6959 public:
6960 
6963 
6967  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6968 
6973 
6978  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6979 
6980 
6984  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6985 
6987 
6988  HPS::Type ObjectType() const {return HPS::Type::FontSearchResultsIterator;}
6989 
6990 
6995  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6996 
6998  void Next();
6999 
7002  FontSearchResultsIterator & operator++();
7003 
7006  FontSearchResultsIterator operator++(int in_val);
7007 
7010  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
7011 
7014  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
7015 
7019  bool IsValid() const;
7020 
7022  void Reset();
7023 
7027  FontInfoState GetItem() const;
7028 
7031  FontInfoState operator*() const;
7032 
7033 };
7034 
7036 class HPS_API FontSearchResults : public Object
7037 {
7038 public:
7039 
7042 
7045  FontSearchResults(FontSearchResults const & in_search_results);
7046 
7051 
7055  FontSearchResults & operator=(FontSearchResults && in_that);
7056 
7058  virtual void Reset();
7059 
7061  ~FontSearchResults();
7062 
7063  HPS::Type ObjectType() const {return HPS::Type::FontSearchResults;}
7064 
7068  void Assign(FontSearchResults const & in_search_results);
7069 
7070 
7074  FontSearchResults & operator=(FontSearchResults const & in_search_results);
7075 
7078  size_t GetCount() const;
7079 
7082  FontSearchResultsIterator GetIterator() const;
7083 };
7084 
7086 class HPS_API UTF8
7087 {
7088 public:
7089 
7091  UTF8();
7092 
7094  ~UTF8();
7095 
7102  UTF8(char const * in_string, char const * in_locale = 0);
7103 
7106  UTF8(wchar_t const * in_string);
7107 
7110  UTF8(UTF8 const & in_that);
7111 
7114  UTF8(UTF8 && in_that);
7115 
7119  UTF8 & Assign(UTF8 && in_utf8);
7120 
7123  inline UTF8 & operator= (UTF8 && in_utf8)
7124  {
7125  return Assign(std::move(in_utf8));
7126  }
7127 
7132  size_t ToWStr(wchar_t * out_wide_string) const;
7133 
7137  size_t ToWStr(WCharArray & out_wide_string) const;
7138 
7141  inline bool IsValid() const
7142  {
7143  return (_length > 0);
7144  }
7145 
7148  inline bool Empty() const
7149  {
7150  return (_length == 0);
7151  }
7152 
7154  void Clear();
7155 
7157  void Reset() { Clear(); }
7158 
7162  inline size_t GetLength() const
7163  {
7164  return _length;
7165  }
7166 
7170  inline size_t GetWStrLength() const
7171  {
7172  return ToWStr(0);
7173  }
7174 
7177  inline char const * GetBytes() const
7178  {
7179  return _text;
7180  }
7181 
7184  inline operator char const * () const
7185  {
7186  return _text;
7187  }
7188 
7191  char At(size_t in_index) const
7192  {
7193  if(!IsValid())
7194  throw InvalidObjectException();
7195  else if(in_index >= _length)
7196  throw IndexOutOfRangeException();
7197  else
7198  return _text[in_index];
7199  }
7200 
7204  UTF8 & Assign(UTF8 const & in_utf8);
7205 
7209  inline UTF8 & operator= (UTF8 const & in_utf8)
7210  {
7211  return Assign(in_utf8);
7212  }
7213 
7217  UTF8 & operator+= (UTF8 const & in_utf8);
7218 
7222  UTF8 & operator+= (char const * in_utf8);
7223 
7227  UTF8 operator+ (UTF8 const & in_utf8) const;
7228 
7232  UTF8 operator+ (char const * in_utf8) const;
7233 
7237  bool operator== (UTF8 const & in_utf8) const;
7238 
7242  bool operator!= (UTF8 const & in_utf8) const
7243  {
7244  return !(*this == in_utf8);
7245  }
7246 
7250  bool operator== (char const * in_utf8) const;
7251 
7255  bool operator!= (char const * in_utf8) const
7256  {
7257  return !(*this == in_utf8);
7258  }
7259 
7264  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
7265  {
7266  return in_right == in_left;
7267  }
7268 
7273  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
7274  {
7275  return in_right != in_left;
7276  }
7277 
7282  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
7283  {
7284  return in_right == UTF8(in_left);
7285  }
7286 
7291  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
7292  {
7293  return in_right != UTF8(in_left);
7294  }
7295 
7300  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
7301  {
7302  return UTF8(in_left, "utf8") + in_right;
7303  }
7304 
7309  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
7310  {
7311  return UTF8(in_left) + in_right;
7312  }
7313 
7314 
7317  size_t GetHash() const;
7318 
7319  friend class HPSI::String;
7320 
7321 private:
7322 
7323  size_t internal_encode(wchar_t const * in_wide_string);
7324  static size_t internal_decode(size_t in_length, const char* in_utf8_string, wchar_t * out_wide_string);
7325  size_t internal_decode(wchar_t * out_wide_string) const;
7326 
7327  char * _text;
7328  size_t _length;
7329  mutable size_t _hash_key;
7330  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
7331  char _buffer[_buffer_size];
7332 };
7333 
7335 struct UTF8Hasher {
7336  inline size_t operator()(const HPS::UTF8 & in_utf8) const
7337  {
7338  return in_utf8.GetHash();
7339  }
7340 };
7341 
7344 class HPS_API ConditionalExpression : public Object
7345 {
7346 public:
7347 
7350 
7353  ConditionalExpression(char const * in_condition);
7354 
7357  ConditionalExpression(float in_number);
7358 
7361  ConditionalExpression(HPS::Condition::Intrinsic in_special);
7362 
7366 
7371 
7375  ConditionalExpression & operator=(ConditionalExpression && in_that);
7376 
7377  HPS::Type ObjectType() const { return HPS::Type::ConditionalExpression; }
7378 
7382  bool ShowCondition(UTF8 & out_condition) const;
7383 
7387  bool ShowNumber(float & out_number) const;
7388 
7392  bool ShowIntrinsic(Condition::Intrinsic & out_special) const;
7393 
7397  bool ShowOperands(ConditionalExpressionArray & out_operands) const;
7398 
7402  ConditionalExpression & operator=(ConditionalExpression const & in_that);
7403 
7407  bool Equals(ConditionalExpression const & in_that) const;
7408 
7412  bool operator==(ConditionalExpression const & in_that) const;
7413 
7417  bool operator!=(ConditionalExpression const & in_that) const;
7418 
7422  bool IsSatisfiedBy(UTF8Array const & in_conditions) const;
7423 
7427  bool IsSatisfiedBy(char const * in_condition) const;
7428 
7432  ConditionalExpression OR(ConditionalExpression const & in_operand2) const;
7433 
7437  ConditionalExpression XOR(ConditionalExpression const & in_operand2) const;
7438 
7442  ConditionalExpression AND(ConditionalExpression const & in_operand2) const;
7443 
7447  ConditionalExpression EQ(ConditionalExpression const & in_operand2) const;
7448 
7452  ConditionalExpression NEQ(ConditionalExpression const & in_operand2) const;
7453 
7457  ConditionalExpression GT(ConditionalExpression const & in_operand2) const;
7458 
7462  ConditionalExpression LT(ConditionalExpression const & in_operand2) const;
7463 
7467  ConditionalExpression GTEQ(ConditionalExpression const & in_operand2) const;
7468 
7472  ConditionalExpression LTEQ(ConditionalExpression const & in_operand2) const;
7473 
7476  ConditionalExpression operator !() const;
7477 
7481  ConditionalExpression operator ||(ConditionalExpression const & in_operand2) const;
7482 
7486  ConditionalExpression operator ^(ConditionalExpression const & in_operand2) const;
7487 
7491  ConditionalExpression operator &&(ConditionalExpression const & in_operand2) const;
7492 
7493 
7497  static ConditionalExpression NOT(ConditionalExpression const & in_operand);
7498 
7503  static ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7504 
7505 
7510  static ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7511 
7516  static ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7517 
7522  static ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7523 
7528  static ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7529 
7534  static ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7535 
7540  static ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7541 
7546  static ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7547 
7552  static ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7553 
7554  friend HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7555  friend HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7556  friend HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7557  friend HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7558 
7559  friend HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7560  friend HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7561  friend HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7562  friend HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7563  friend HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7564  friend HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7565 };
7566 
7567 
7571 HPS_API ConditionalExpression NOT(ConditionalExpression const & in_operand);
7572 
7577 HPS_API ConditionalExpression OR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7578 
7583 HPS_API ConditionalExpression XOR(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7584 
7589 HPS_API ConditionalExpression AND(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7590 
7595 HPS_API ConditionalExpression EQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7596 
7601 HPS_API ConditionalExpression NEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7602 
7607 HPS_API ConditionalExpression GT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7608 
7613 HPS_API ConditionalExpression LT(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7614 
7619 HPS_API ConditionalExpression GTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7620 
7625 HPS_API ConditionalExpression LTEQ(ConditionalExpression const & in_operand1, ConditionalExpression const & in_operand2);
7626 
7627 
7628 
7632 class HPS_API Key : public Object
7633 {
7634 public:
7635 
7637  Key();
7638 
7640  Key(Key const & in_that);
7641 
7643  explicit Key(Control const & in_control);
7644 
7648  Key(Key && in_that);
7649 
7653  Key & operator=(Key && in_that);
7654 
7656  virtual ~Key();
7657 
7658  HPS::Type ObjectType() const {return HPS::Type::Key;};
7659 
7661  bool HasOwner() const;
7662 
7664  SegmentKey Up() const;
7665 
7667  SegmentKey Owner() const;
7668 
7670  void Delete();
7671 
7673  void MoveTo(SegmentKey const & in_new_owner);
7674 
7677  Key CopyTo(SegmentKey const & in_destination) const;
7678 
7682  Key & operator=(Key const & in_that);
7683 
7686  virtual void Assign(Key const & in_that);
7687 
7689  bool Equals(Key const & in_that) const;
7690 
7692  bool operator!= (Key const & in_that) const;
7693 
7695  bool operator== (Key const & in_that) const;
7696 
7699  size_t GetHash() const;
7700 };
7701 
7703 struct KeyHasher {
7704  inline size_t operator()(const HPS::Key & in_key) const
7705  {
7706  return in_key.GetHash();
7707  }
7708 };
7709 
7710 
7713 class HPS_API SegmentKey : public Key
7714 {
7715 public:
7717  SegmentKey();
7718 
7720  SegmentKey(SegmentKey const & in_that);
7721 
7723  SegmentKey & operator=(SegmentKey const & other);
7724 
7728  SegmentKey(SegmentKey && in_that);
7729 
7733  SegmentKey & operator=(SegmentKey && in_that);
7734 
7736  explicit SegmentKey(Key const & in_that);
7737 
7739  ~SegmentKey();
7740 
7741  HPS::Type ObjectType() const {return HPS::Type::SegmentKey;};
7742 
7744  UTF8 Name() const;
7745 
7748  SegmentKey & SetName(char const * in_name);
7749 
7752  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7753 
7756  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7757 
7759  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7760 
7762  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7763 
7765  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7766 
7767 
7768 
7770  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7771 
7773  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7774 
7776  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7777 
7778 
7780  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7781 
7783  size_t Find(SearchOptionsKit const & in_options) const;
7784 
7785 
7788  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7789 
7793  IncludeKey IncludeSegment(SegmentKey const & in_seg, ConditionalExpression const & in_conditional);
7794 
7795 
7801  ReferenceKey ReferenceGeometry(Key const & in_key);
7802 
7810  ReferenceKey ReferenceGeometry(Key const & in_key, ConditionalExpression const & in_conditional);
7811 
7812 
7814  size_t ShowSubsegments() const;
7815 
7817  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7818 
7822  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7823 
7827  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7828 
7832  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7833 
7837  size_t ShowStylers(StyleKeyArray & out_styles) const;
7838 
7842  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7843 
7847  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7848 
7849 
7850 
7852  StyleControl GetStyleControl();
7853 
7855  StyleControl const GetStyleControl() const;
7856 
7857 
7859  PortfolioControl GetPortfolioControl();
7860 
7862  PortfolioControl const GetPortfolioControl() const;
7863 
7864 
7866  SegmentKey & SetCondition(char const * in_condition);
7867 
7869  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7870 
7872  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7873 
7875  SegmentKey & UnsetConditions();
7876 
7878  bool ShowConditions(UTF8Array & out_conditions) const;
7879 
7881  ConditionControl GetConditionControl();
7882 
7884  ConditionControl const GetConditionControl() const;
7885 
7886 
7888  SegmentKey & SetMaterialPalette(char const * in_name);
7889 
7891  SegmentKey & UnsetMaterialPalette();
7892 
7894  bool ShowMaterialPalette(UTF8 & out_name) const;
7895 
7896 
7903  SegmentKey & SetPriority(int in_priority);
7904 
7907  SegmentKey & UnsetPriority();
7908 
7912  bool ShowPriority(int & out_priority) const;
7913 
7918  SegmentKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
7919 
7925  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7926 
7931  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7932 
7936  SegmentKey & UnsetUserData(intptr_t in_index);
7937 
7942  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7943 
7947  SegmentKey & UnsetUserData(HPS::IntPtrTArray const & in_indices);
7948 
7951  SegmentKey & UnsetAllUserData();
7952 
7954  size_t ShowUserDataCount() const;
7955 
7960  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
7961 
7965  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7966 
7971  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7972 
7973 
7975  LineKey InsertLine(LineKit const & in_kit);
7976 
7978  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7979 
7981  LineKey InsertLine(PointArray const & in_pts);
7982 
7984  LineKey InsertLine(Point const & pt1, Point const & pt2);
7985 
7986 
7988  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7989 
7991  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);
7992 
7994  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7995 
7997  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7998 
7999 
8004  SphereKey InsertSphere(SphereKit const & in_kit);
8005 
8013  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));
8014 
8016  CircleKey InsertCircle(CircleKit const & in_kit);
8017 
8019  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
8020 
8022  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
8023 
8024 
8026  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
8027 
8029  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
8030 
8031 
8033  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
8034 
8036  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
8037 
8038 
8040  EllipseKey InsertEllipse(EllipseKit const & in_kit);
8041 
8043  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
8044 
8045 
8047  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
8048 
8050  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float in_start, float in_end);
8051 
8052 
8054  PolygonKey InsertPolygon(PolygonKit const & in_kit);
8055 
8057  PolygonKey InsertPolygon(PointArray const & in_points);
8058 
8060  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
8061 
8062 
8064  ShellKey InsertShell(ShellKit const & in_kit);
8065 
8067  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
8068 
8070  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
8071 
8079  ShellKey InsertShellByTristrips(PointArray const & in_points, IntArray const & in_tristrips);
8080 
8082  ShellKey InsertShellByTristrips(size_t in_point_count, Point const in_points [], size_t in_tristrips_count, int const in_tristrips []);
8083 
8085  MeshKey InsertMesh(MeshKit const & in_kit);
8086 
8088  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
8089 
8091  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
8092 
8093 
8095  MarkerKey InsertMarker(Point const & in_position);
8096 
8098  MarkerKey InsertMarker(MarkerKit const & in_kit);
8099 
8100 
8102  DistantLightKey InsertDistantLight(Vector const & in_direction);
8103 
8105  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
8106 
8107 
8109  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
8110 
8112  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
8113 
8115  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
8116 
8118  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
8119 
8120 
8122  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
8123 
8125  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
8126 
8127 
8129  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
8130 
8132  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
8133 
8134 
8136  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
8137 
8139  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);
8140 
8142  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);
8143 
8144 
8146  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
8147 
8149  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);
8150 
8152  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[]);
8153 
8155  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);
8156 
8158  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[]);
8159 
8160 
8162  TextKey InsertText(TextKit const & in_kit);
8163 
8168  TextKey InsertText(Point const & in_position, char const * in_text);
8169 
8170 
8171 
8173  GridKey InsertGrid(GridKit const & in_kit);
8174 
8176  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);
8177 
8178 
8179 
8186  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
8187 
8195  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
8196 
8204  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
8205 
8213  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
8214 
8222  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
8223 
8231  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
8232 
8237  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
8238 
8243  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
8244 
8249  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
8250 
8255  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
8256 
8261  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
8262 
8267  ShellKey InsertShellFromGeometry(TextKey const & in_text);
8268 
8269 
8271  SegmentKey & SetAttributeLock(AttributeLockKit const & in_kit);
8272 
8274  SegmentKey & UnsetAttributeLock();
8275 
8279  bool ShowAttributeLock(AttributeLockKit & out_kit) const;
8280 
8282  AttributeLockControl GetAttributeLockControl();
8283 
8285  AttributeLockControl const GetAttributeLockControl() const;
8286 
8287 
8289  SegmentKey & SetBounding(BoundingKit const & in_kit);
8290 
8292  SegmentKey & UnsetBounding();
8293 
8297  bool ShowBounding(BoundingKit & out_kit) const;
8298 
8300  BoundingControl GetBoundingControl();
8301 
8303  BoundingControl const GetBoundingControl() const;
8304 
8305 
8307  SegmentKey & SetCamera(CameraKit const & in_kit);
8308 
8310  SegmentKey & UnsetCamera();
8311 
8313  bool ShowCamera(CameraKit & out_kit) const;
8314 
8316  CameraControl GetCameraControl();
8317 
8319  CameraControl const GetCameraControl() const;
8320 
8321 
8323  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
8324 
8326  SegmentKey & UnsetColorInterpolation();
8327 
8329  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
8330 
8332  ColorInterpolationControl GetColorInterpolationControl();
8333 
8335  ColorInterpolationControl const GetColorInterpolationControl() const;
8336 
8337 
8339  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
8340 
8342  SegmentKey & UnsetContourLine();
8343 
8345  bool ShowContourLine(ContourLineKit & out_kit) const;
8346 
8348  ContourLineControl GetContourLineControl();
8349 
8351  ContourLineControl const GetContourLineControl() const;
8352 
8353 
8355  SegmentKey & SetCulling(CullingKit const & in_kit);
8356 
8358  SegmentKey & UnsetCulling();
8359 
8363  bool ShowCulling(CullingKit & out_kit) const;
8364 
8366  CullingControl GetCullingControl();
8367 
8369  CullingControl const GetCullingControl() const;
8370 
8371 
8373  SegmentKey & SetCurveAttribute(CurveAttributeKit const & in_kit);
8374 
8376  SegmentKey & UnsetCurveAttribute();
8377 
8379  bool ShowCurveAttribute(CurveAttributeKit & out_kit) const;
8380 
8382  CurveAttributeControl GetCurveAttributeControl();
8383 
8385  CurveAttributeControl const GetCurveAttributeControl() const;
8386 
8387 
8389  SegmentKey & SetCuttingSectionAttribute(CuttingSectionAttributeKit const & in_kit);
8390 
8392  SegmentKey & UnsetCuttingSectionAttribute();
8393 
8395  bool ShowCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
8396 
8398  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
8399 
8401  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
8402 
8403 
8405  SegmentKey & SetCylinderAttribute(CylinderAttributeKit const & in_kit);
8406 
8408  SegmentKey & UnsetCylinderAttribute();
8409 
8411  bool ShowCylinderAttribute(CylinderAttributeKit & out_kit) const;
8412 
8414  CylinderAttributeControl GetCylinderAttributeControl();
8415 
8417  CylinderAttributeControl const GetCylinderAttributeControl() const;
8418 
8419 
8421  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
8422 
8424  SegmentKey & UnsetDrawingAttribute();
8425 
8427  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
8428 
8430  DrawingAttributeControl GetDrawingAttributeControl();
8431 
8433  DrawingAttributeControl const GetDrawingAttributeControl() const;
8434 
8435 
8437  SegmentKey & SetEdgeAttribute(EdgeAttributeKit const & in_kit);
8438 
8440  SegmentKey & UnsetEdgeAttribute();
8441 
8443  bool ShowEdgeAttribute(EdgeAttributeKit & out_kit) const;
8444 
8446  EdgeAttributeControl GetEdgeAttributeControl();
8447 
8449  EdgeAttributeControl const GetEdgeAttributeControl() const;
8450 
8451 
8453  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
8454 
8456  SegmentKey & UnsetHiddenLineAttribute();
8457 
8459  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8460 
8462  HiddenLineAttributeControl GetHiddenLineAttributeControl();
8463 
8465  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
8466 
8467 
8469  SegmentKey & SetLightingAttribute(LightingAttributeKit const & in_kit);
8470 
8472  SegmentKey & UnsetLightingAttribute();
8473 
8475  bool ShowLightingAttribute(LightingAttributeKit & out_kit) const;
8476 
8478  LightingAttributeControl GetLightingAttributeControl();
8479 
8481  LightingAttributeControl const GetLightingAttributeControl() const;
8482 
8483 
8485  SegmentKey & SetLineAttribute(LineAttributeKit const & in_kit);
8486 
8488  SegmentKey & UnsetLineAttribute();
8489 
8491  bool ShowLineAttribute(LineAttributeKit & out_kit) const;
8492 
8494  LineAttributeControl GetLineAttributeControl();
8495 
8497  LineAttributeControl const GetLineAttributeControl() const;
8498 
8499 
8501  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
8502 
8504  SegmentKey & UnsetMaterialMapping();
8505 
8507  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
8508 
8510  MaterialMappingControl GetMaterialMappingControl();
8511 
8513  MaterialMappingControl const GetMaterialMappingControl() const;
8514 
8515 
8517  SegmentKey & SetMarkerAttribute(MarkerAttributeKit const & in_kit);
8518 
8520  SegmentKey & UnsetMarkerAttribute();
8521 
8523  bool ShowMarkerAttribute(MarkerAttributeKit & out_kit) const;
8524 
8526  MarkerAttributeControl GetMarkerAttributeControl();
8527 
8529  MarkerAttributeControl const GetMarkerAttributeControl() const;
8530 
8531 
8533  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
8534 
8536  SegmentKey & UnsetModellingMatrix();
8537 
8539  bool ShowModellingMatrix(MatrixKit & out_kit) const;
8540 
8542  ModellingMatrixControl GetModellingMatrixControl();
8543 
8545  ModellingMatrixControl const GetModellingMatrixControl() const;
8546 
8547 
8549  SegmentKey & SetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit const & in_kit);
8550 
8552  SegmentKey & UnsetNURBSSurfaceAttribute();
8553 
8555  bool ShowNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
8556 
8558  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
8559 
8561  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
8562 
8563 
8565  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
8566 
8568  SegmentKey & UnsetPerformance();
8569 
8571  bool ShowPerformance(PerformanceKit & out_kit) const;
8572 
8574  PerformanceControl GetPerformanceControl();
8575 
8577  PerformanceControl const GetPerformanceControl() const;
8578 
8579 
8581  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
8582 
8584  SegmentKey & UnsetSelectability();
8585 
8589  bool ShowSelectability(SelectabilityKit & out_kit) const;
8590 
8592  SelectabilityControl GetSelectabilityControl();
8593 
8595  SelectabilityControl const GetSelectabilityControl() const;
8596 
8597 
8599  SegmentKey & SetSphereAttribute(SphereAttributeKit const & in_kit);
8600 
8602  SegmentKey & UnsetSphereAttribute();
8603 
8606  bool ShowSphereAttribute(SphereAttributeKit & out_kit) const;
8607 
8609  SphereAttributeControl GetSphereAttributeControl();
8610 
8612  SphereAttributeControl const GetSphereAttributeControl() const;
8613 
8614 
8616  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8617 
8619  SegmentKey & UnsetSubwindow();
8620 
8623  bool ShowSubwindow(SubwindowKit & out_kit) const;
8624 
8626  SubwindowControl GetSubwindowControl();
8627 
8629  SubwindowControl const GetSubwindowControl() const;
8630 
8631 
8633  SegmentKey & SetTextAttribute(TextAttributeKit const & in_kit);
8634 
8636  SegmentKey & UnsetTextAttribute();
8637 
8639  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
8640 
8642  TextAttributeControl GetTextAttributeControl();
8643 
8645  TextAttributeControl const GetTextAttributeControl() const;
8646 
8647 
8649  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8650 
8652  SegmentKey & UnsetTextureMatrix();
8653 
8656  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8657 
8659  TextureMatrixControl GetTextureMatrixControl();
8660 
8662  TextureMatrixControl const GetTextureMatrixControl() const;
8663 
8664 
8666  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8667 
8669  SegmentKey & UnsetTransformMask();
8670 
8673  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8674 
8676  TransformMaskControl GetTransformMaskControl();
8677 
8679  TransformMaskControl const GetTransformMaskControl() const;
8680 
8681 
8683  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8684 
8686  SegmentKey & UnsetTransparency();
8687 
8690  bool ShowTransparency(TransparencyKit & out_kit) const;
8691 
8693  TransparencyControl GetTransparencyControl();
8694 
8696  TransparencyControl const GetTransparencyControl() const;
8697 
8698 
8700  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8701 
8703  SegmentKey & UnsetVisibility();
8704 
8707  bool ShowVisibility(VisibilityKit & out_kit) const;
8708 
8710  VisibilityControl GetVisibilityControl();
8711 
8713  VisibilityControl const GetVisibilityControl() const;
8714 
8715 
8717  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8718 
8720  SegmentKey & UnsetVisualEffects();
8721 
8725  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8726 
8728  VisualEffectsControl GetVisualEffectsControl();
8729 
8731  VisualEffectsControl const GetVisualEffectsControl() const;
8732 
8733  void Optimize(SegmentOptimizationOptionsKit const & in_kit);
8734 };
8735 
8736 
8738 class HPS_API SegmentOptimizationOptionsKit : public Kit
8739 {
8740 public:
8741 
8744 
8748 
8752 
8753  virtual ~SegmentOptimizationOptionsKit();
8754 
8755  HPS::Type ObjectType() const { return HPS::Type::SegmentOptimizationOptionsKit; }
8756 
8759  void Consume(SegmentOptimizationOptionsKit & in_kit);
8760 
8763  void Set(SegmentOptimizationOptionsKit const & in_kit);
8764 
8767  void Show(SegmentOptimizationOptionsKit & out_kit) const;
8768 
8773 
8778 
8781  bool Empty() const;
8782 
8786  bool Equals(SegmentOptimizationOptionsKit const & in_kit) const;
8787 
8791  bool operator==(SegmentOptimizationOptionsKit const & in_kit) const;
8792 
8796  bool operator!=(SegmentOptimizationOptionsKit const & in_kit) const;
8797 
8801  SegmentOptimizationOptionsKit & SetUserData(HPS::SegmentOptimizationOptions::UserData in_user_data);
8802 
8806  SegmentOptimizationOptionsKit & SetMatrix(HPS::SegmentOptimizationOptions::Matrix in_matrix);
8807 
8811  SegmentOptimizationOptionsKit & SetExpansion(HPS::SegmentOptimizationOptions::Expansion in_expansion);
8812 
8816  SegmentOptimizationOptionsKit & SetScope(HPS::SegmentOptimizationOptions::Scope in_scope);
8817 
8821  SegmentOptimizationOptionsKit & SetReorganization(HPS::SegmentOptimizationOptions::Reorganization in_reorganization);
8822 
8826  SegmentOptimizationOptionsKit & SetShellInstancing(bool in_shell_instancing);
8827 
8831  SegmentOptimizationOptionsKit & SetShellMerging(bool in_shell_merging);
8832 
8836  SegmentOptimizationOptionsKit & SetAttributeDelocalization(bool in_attribute_delocalization);
8837 
8839  SegmentOptimizationOptionsKit & UnsetUserData();
8840 
8842  SegmentOptimizationOptionsKit & UnsetMatrix();
8843 
8845  SegmentOptimizationOptionsKit & UnsetExpansion();
8846 
8848  SegmentOptimizationOptionsKit & UnsetScope();
8849 
8851  SegmentOptimizationOptionsKit & UnsetReorganization();
8852 
8854  SegmentOptimizationOptionsKit & UnsetShellInstancing();
8855 
8857  SegmentOptimizationOptionsKit & UnsetShellMerging();
8858 
8860  SegmentOptimizationOptionsKit & UnsetAttributeDelocalization();
8861 
8864  SegmentOptimizationOptionsKit & UnsetEverything();
8865 
8866  bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data) const;
8867 
8868  bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix) const;
8869 
8870  bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion) const;
8871 
8872  bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope) const;
8873 
8874  bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization) const;
8875 
8876  bool ShowShellInstancing(bool & out_shell_instancing) const;
8877 
8878  bool ShowShellMerging(bool & out_shell_merging) const;
8879 
8880  bool ShowAttributeDelocalization(bool & out_attribute_delocalization) const;
8881 };
8882 
8883 
8886 class HPS_API UpdateNotifier : public Object
8887 {
8888 public:
8889 
8890  UpdateNotifier();
8891 
8892  UpdateNotifier(UpdateNotifier const & in_that);
8893 
8897  UpdateNotifier(UpdateNotifier && in_that);
8898 
8902  UpdateNotifier & operator=(UpdateNotifier && in_that);
8903 
8904  virtual ~UpdateNotifier();
8905 
8906  HPS::Type ObjectType() const {return HPS::Type::UpdateNotifier;};
8907 
8911  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8912 
8915  void Assign(UpdateNotifier const & in_that);
8916 
8917  void Wait() const;
8918 
8919  void Cancel() const;
8920 
8921  Window::UpdateStatus Status() const;
8922 
8923 };
8924 
8927 class HPS_API DriverEvent
8928 {
8929 public:
8930 
8931  virtual ~DriverEvent();
8932 
8934  intptr_t GetClassID() const;
8935 
8936  enum class StereoMatrix
8937  {
8938  ViewLeft,
8939  ViewRight,
8940  ProjectionLeft,
8941  ProjectionRight,
8942  };
8943 
8944  void SetStereoMatrix(StereoMatrix id, HPS::MatrixKit const & in_matrix) const;
8945  OpaqueHandle GetSurface(int index) const;
8946  OpaqueHandle GetGraphicsContext() const;
8947 
8948 protected:
8949 
8950  DriverEvent(OpaqueHandle in_nr) : nr(in_nr)
8951  {
8952 
8953  }
8954 
8955  OpaqueHandle nr;
8956 };
8957 
8960 class HPS_API FinishPictureEvent : public DriverEvent
8961 {
8962 public:
8963  FinishPictureEvent(OpaqueHandle in_nr = 0);
8964  virtual ~FinishPictureEvent();
8965 };
8966 
8967 class HPS_API InitPictureEvent : public DriverEvent
8968 {
8969 public:
8970  InitPictureEvent(OpaqueHandle in_nr = 0);
8971  virtual ~InitPictureEvent();
8972 
8973  void SetRenderSurface(OpaqueHandle target) const;
8974 };
8975 
8977 class HPS_API DrawWindowEvent : public DriverEvent
8978 {
8979 public:
8980  DrawWindowEvent(OpaqueHandle in_nr = 0);
8981  virtual ~DrawWindowEvent();
8982 
8985 
8990  void DrawTexturedBackground(OpaqueHandle in_texture, MatrixKit const & in_matrix, IntRectangle const & in_extent) const;
8991 
8992 private:
8993 
8994  mutable HPS::FloatArray matrix_elements;
8995 };
8996 
8998 class HPS_API DriverEventHandler : public Object
8999 {
9000 public:
9001 
9002  HPS::Type ObjectType() const OVERRIDE { return HPS::Type::DriverEventHandler; };
9003 
9005 
9006  DriverEventHandler(DriverEventHandler const & that);
9007 
9008  virtual ~DriverEventHandler();
9009 
9013  virtual void Handle(DriverEvent const * in_event)
9014  {
9015  HPS_UNREFERENCED(in_event);
9016  }
9017 };
9018 
9019 
9020 
9021 
9025 class HPS_API WindowKey : public SegmentKey
9026 {
9027 public:
9028 
9030  WindowKey();
9031 
9033  WindowKey(WindowKey const & in_window);
9034 
9036  WindowKey & operator=(WindowKey const & other);
9037 
9041  WindowKey(WindowKey && in_that);
9042 
9046  WindowKey & operator=(WindowKey && in_that);
9047 
9049  WindowKey(Key const & in_key);
9050 
9052  ~WindowKey();
9053 
9054  HPS::Type ObjectType() const {return HPS::Type::WindowKey;};
9055 
9057  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9058 
9063  size_t FindFonts(FontSearchResults & out_results) const;
9064 
9066  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
9067 
9069  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
9070 
9072  PostProcessEffectsControl GetPostProcessEffectsControl();
9073 
9075  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
9076 
9077 
9079  WindowKey & SetDebugging(DebuggingKit const & in_kit);
9080 
9084  WindowKey & SetDriverEventHandler(DriverEventHandler const & in_handler, intptr_t in_type);
9085 
9088  WindowKey & UnsetDriverEventHandler(intptr_t in_type);
9089 
9093  bool ShowDebugging(DebuggingKit & out_kit) const;
9094 
9096  DebuggingControl GetDebuggingControl();
9097 
9099  DebuggingControl const GetDebuggingControl() const;
9100 
9102  WindowInfoControl const GetWindowInfoControl() const;
9103 
9104  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
9105 
9107  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
9108 
9110  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
9111 
9113  WindowKey & SetUpdateOptions(HPS::UpdateOptionsKit const & in_kit);
9114 
9116  bool ShowUpdateOptions(HPS::UpdateOptionsKit & out_kit) const;
9117 
9118 
9120  SelectionOptionsControl GetSelectionOptionsControl();
9121 
9123  SelectionOptionsControl const GetSelectionOptionsControl() const;
9124 
9125 
9127  SelectionControl GetSelectionControl();
9128 
9130  SelectionControl const GetSelectionControl() const;
9131 
9133  HighlightControl GetHighlightControl();
9134 
9136  HighlightControl const GetHighlightControl() const;
9137 
9139  UpdateOptionsControl GetUpdateOptionsControl();
9140 
9142  UpdateOptionsControl const GetUpdateOptionsControl() const;
9143 
9145  void Update();
9146 
9151  void Update(UpdateOptionsKit const & in_kit);
9152 
9167  void Update(Window::UpdateType in_type, Time in_time_limit=-1);
9168 
9172  UpdateNotifier UpdateWithNotifier();
9173 
9177  UpdateNotifier UpdateWithNotifier(HPS::UpdateOptionsKit const & in_kit);
9178 
9184  UpdateNotifier UpdateWithNotifier(Window::UpdateType in_type, Time in_time_limit=-1);
9185 
9187  EventDispatcher & GetEventDispatcher();
9188 
9190  EventDispatcher const & GetEventDispatcher() const;
9191 
9195  bool ShowSnapshot(ImageKit & out_kit) const;
9196 
9197 private:
9198 
9200  SegmentKey & UnsetAttributeLock();
9201  SegmentKey & UnsetCamera();
9202  SegmentKey & UnsetColorInterpolation();
9203  SegmentKey & UnsetContourLine();
9204  SegmentKey & UnsetCulling();
9205  SegmentKey & UnsetCurveAttribute();
9206  SegmentKey & UnsetCuttingSectionAttribute();
9207  SegmentKey & UnsetCylinderAttribute();
9208  SegmentKey & UnsetDrawingAttribute();
9209  SegmentKey & UnsetEdgeAttribute();
9210  SegmentKey & UnsetHiddenLineAttribute();
9211  SegmentKey & UnsetLightingAttribute();
9212  SegmentKey & UnsetLineAttribute();
9213  SegmentKey & UnsetMaterialMapping();
9214  SegmentKey & UnsetMarkerAttribute();
9215  SegmentKey & UnsetModellingMatrix();
9216  SegmentKey & UnsetNURBSSurfaceAttribute();
9217  SegmentKey & UnsetPerformance();
9218  SegmentKey & UnsetSelectability();
9219  SegmentKey & UnsetSphereAttribute();
9220  SegmentKey & UnsetSubwindow();
9221  SegmentKey & UnsetTextAttribute();
9222  SegmentKey & UnsetTextureMatrix();
9223  SegmentKey & UnsetTransformMask();
9224  SegmentKey & UnsetTransparency();
9225  SegmentKey & UnsetVisibility();
9226  SegmentKey & UnsetVisualEffects();
9227 
9229  void MoveTo(SegmentKey const & in_new_owner);
9230 
9232  Key CopyTo(SegmentKey const & in_destination) const;
9233 };
9234 
9235 
9236 
9239 class HPS_API KeyPath : public Object
9240 {
9241 public:
9242 
9244  KeyPath();
9245 
9248  KeyPath(KeyArray const & in_path);
9249 
9253  KeyPath(size_t in_path_count, Key const in_path []);
9254 
9256  KeyPath(KeyPath const & in_that);
9257 
9261  KeyPath(KeyPath && in_that);
9262 
9266  KeyPath & operator=(KeyPath && in_that);
9267 
9269  virtual ~KeyPath();
9270 
9271  HPS::Type ObjectType() const { return HPS::Type::KeyPath; }
9272 
9276  KeyPath & operator+=(Key const & in_key);
9277 
9281  KeyPath & operator+=(KeyPath const & in_key_path);
9282 
9286  KeyPath & operator+=(KeyArray const & in_key_array);
9287 
9291  KeyPath & Append(Key const & in_key);
9292 
9296  KeyPath & Append(KeyPath const & in_key_path);
9297 
9301  KeyPath & Append(KeyArray const & in_key_array);
9302 
9306  KeyPath & operator=(KeyPath const & in_that);
9307 
9311  KeyPath & operator=(KeyArray const & in_path);
9312 
9315  void Set(KeyPath const & in_that);
9316 
9320  bool Equals(KeyPath const & in_that) const;
9321 
9325  bool operator!= (KeyPath const & in_that) const;
9326 
9330  bool operator== (KeyPath const & in_that) const;
9331 
9332 
9336  KeyPath & SetKeys(KeyArray const & in_keys);
9337 
9342  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
9343 
9344 
9347  KeyPath & UnsetKeys();
9348 
9349 
9352  bool ShowKeys(KeyArray & out_keys) const;
9353 
9354 
9361  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
9362 
9369  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
9370 
9378  bool ComputeTextExtent(char const * in_text, float & out_xfrac, float & out_yfrac) const;
9379 
9385  bool ComputeExtent(Rectangle & out_extent) const;
9386 
9393  bool ComputeExtent(HPS::VisibilityKit const & in_vis, Rectangle & out_extent) const;
9394 
9395 
9402  bool ComputeExtent(HPS::Extent::ClipRegion in_clip, Rectangle & out_extent) const;
9403 
9404 
9412  bool ComputeExtent(HPS::VisibilityKit const & in_vis, HPS::Extent::ClipRegion in_clip, Rectangle & out_extent) const;
9413 
9419  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, HPS::MatrixKit & out_matrix) const;
9420 
9423  bool ShowNetVisibility(VisibilityKit & out_kit) const;
9424 
9427  bool ShowNetBounding(BoundingKit & out_kit) const;
9428 
9431  bool ShowNetCamera(CameraKit & out_kit) const;
9432 
9435  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
9436 
9439  bool ShowNetContourLine(ContourLineKit & out_kit) const;
9440 
9443  bool ShowNetPerformance(PerformanceKit & out_kit) const;
9444 
9447  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
9448 
9451  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
9452 
9455  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
9456 
9459  bool ShowNetMarkerAttribute(MarkerAttributeKit & out_kit) const;
9460 
9463  bool ShowNetSphereAttribute(SphereAttributeKit & out_kit) const;
9464 
9467  bool ShowNetLightingAttribute(LightingAttributeKit & out_kit) const;
9468 
9471  bool ShowNetCylinderAttribute(CylinderAttributeKit & out_kit) const;
9472 
9475  bool ShowNetCuttingSectionAttribute(CuttingSectionAttributeKit & out_kit) const;
9476 
9479  bool ShowNetTextAttribute(TextAttributeKit & out_kit) const;
9480 
9483  bool ShowNetLineAttribute(LineAttributeKit & out_kit) const;
9484 
9487  bool ShowNetEdgeAttribute(EdgeAttributeKit & out_kit) const;
9488 
9491  bool ShowNetCurveAttribute(CurveAttributeKit & out_kit) const;
9492 
9495  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
9496 
9499  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
9500 
9503  bool ShowNetCulling(CullingKit & out_kit) const;
9504 
9507  bool ShowNetTransparency(TransparencyKit & out_kit) const;
9508 
9511  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
9512 
9515  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
9516 
9519  bool ShowNetNURBSSurfaceAttribute(NURBSSurfaceAttributeKit & out_kit) const;
9520 
9523  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
9524 
9527  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
9528 
9531  bool ShowNetAttributeLock(AttributeLockKit & out_kit) const;
9532 
9535  bool ShowNetConditions(UTF8Array & out_conditions) const;
9536 
9542  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
9543 
9544 
9551  bool ShowNetClipRegions(PointArrayArrayArray & out_loops_array, ClipSpaceArray & out_spaces, ClipOperationArray & out_operations, MatrixKitArray & out_matrices) const;
9552 
9555  bool ShowNetMaterialPalette(UTF8 & out_name) const;
9556 
9561  bool ShowEffectiveMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_def) const;
9562 
9567  bool ShowEffectiveGlyphDefinition(char const * in_name, GlyphDefinition & out_def) const;
9568 
9573  bool ShowEffectiveLinePatternDefinition(char const * in_name, LinePatternDefinition & out_def) const;
9574 
9579  bool ShowEffectiveShaderDefinition(char const * in_name, ShaderDefinition & out_def) const;
9580 
9585  bool ShowEffectiveTextureDefinition(char const * in_name, TextureDefinition & out_def) const;
9586 
9591  bool ShowEffectiveImageDefinition(char const * in_name, ImageDefinition & out_def) const;
9592 };
9593 
9594 
9599 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
9600 {
9601  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9602 }
9603 
9608 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
9609 {
9610  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9611 }
9612 
9617 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
9618 {
9619  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9620 }
9621 
9626 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
9627 {
9628  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9629 }
9630 
9635 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
9636 {
9637  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9638 }
9639 
9644 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
9645 {
9646  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9647 }
9648 
9653 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
9654 {
9655  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9656 }
9657 
9662 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
9663 {
9664  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9665 }
9666 
9671 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
9672 {
9673  return HPS::KeyPath().Append(in_lhs).Append(in_rhs);
9674 }
9675 
9676 
9680 
9682 class HPS_API BoundingKit : public Kit
9683 {
9684 public:
9685 
9687  BoundingKit();
9688 
9691  BoundingKit(BoundingKit const & in_kit);
9692 
9696  BoundingKit(BoundingKit && in_that);
9697 
9701  BoundingKit & operator=(BoundingKit && in_that);
9702 
9704  virtual ~BoundingKit();
9705 
9706  HPS::Type ObjectType() const {return HPS::Type::BoundingKit;};
9707 
9711  static BoundingKit GetDefault();
9712 
9715  void Set(BoundingKit const & in_kit);
9716 
9719  void Show(BoundingKit & out_kit) const;
9720 
9724  BoundingKit & operator=(BoundingKit const & in_kit);
9725 
9728  bool Empty() const;
9729 
9733  bool Equals(BoundingKit const & in_kit) const;
9734 
9738  bool operator==(BoundingKit const & in_kit) const;
9739 
9743  bool operator!=(BoundingKit const & in_kit) const;
9744 
9745 
9749  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
9750 
9754  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
9755 
9759  BoundingKit & SetExclusion(bool in_exclude);
9760 
9761 
9764  BoundingKit & UnsetVolume();
9765 
9768  BoundingKit & UnsetExclusion();
9769 
9772  BoundingKit & UnsetEverything();
9773 
9774 
9779  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9780 
9784  bool ShowExclusion(bool & out_exclusion) const;
9785 
9786 };
9787 
9788 
9791 class HPS_API BoundingControl : public Control
9792 {
9793 public:
9794 
9796  explicit BoundingControl(SegmentKey & in_seg);
9797 
9799  BoundingControl(BoundingControl const & in_that);
9800 
9804  BoundingControl(BoundingControl && in_that);
9805 
9809  BoundingControl & operator=(BoundingControl && in_that);
9810 
9812  ~BoundingControl();
9813 
9814  virtual HPS::Type Type() const { return ObjectType(); }
9815 
9816  HPS::Type ObjectType() const {return HPS::Type::BoundingControl;};
9817 
9821  BoundingControl & operator=(BoundingControl const & in_that);
9822 
9827  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
9828 
9832  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
9833 
9837  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
9838 
9842  BoundingControl & SetExclusion(bool in_exclusion);
9843 
9844 
9848  BoundingControl & UnsetVolume();
9849 
9853  BoundingControl & UnsetExclusion();
9854 
9858  BoundingControl & UnsetEverything();
9859 
9860 
9865  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
9866 
9870  bool ShowExclusion(bool & out_exclusion) const;
9871 
9872 private:
9874  BoundingControl();
9875 };
9876 
9877 
9879 class HPS_API VisibilityKit : public Kit
9880 {
9881 public:
9882 
9884  VisibilityKit();
9885 
9888  VisibilityKit(VisibilityKit const & in_kit);
9889 
9893  VisibilityKit(VisibilityKit && in_that);
9894 
9898  VisibilityKit & operator=(VisibilityKit && in_that);
9899 
9901  virtual ~VisibilityKit();
9902 
9903  HPS::Type ObjectType() const {return HPS::Type::VisibilityKit;};
9904 
9908  static VisibilityKit GetDefault();
9909 
9912  void Set(VisibilityKit const & in_kit);
9913 
9916  void Show(VisibilityKit & out_kit) const;
9917 
9921  VisibilityKit & operator=(VisibilityKit const & in_kit);
9922 
9925  bool Empty() const;
9926 
9930  bool Equals(VisibilityKit const & in_kit) const;
9931 
9935  bool operator==(VisibilityKit const & in_kit) const;
9936 
9940  bool operator!=(VisibilityKit const & in_kit) const;
9941 
9942 
9946  VisibilityKit & SetCuttingSections(bool in_state);
9947 
9951  VisibilityKit & SetCutEdges(bool in_state);
9952 
9956  VisibilityKit & SetCutFaces(bool in_state);
9957 
9961  VisibilityKit & SetWindows(bool in_state);
9962 
9966  VisibilityKit & SetText(bool in_state);
9967 
9971  VisibilityKit & SetLines(bool in_state);
9972 
9976  VisibilityKit & SetEdgeLights(bool in_state);
9977 
9981  VisibilityKit & SetMarkerLights(bool in_state);
9982 
9986  VisibilityKit & SetFaceLights(bool in_state);
9987 
9991  VisibilityKit & SetGenericEdges(bool in_state);
9992 
9996  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9997 
10004  VisibilityKit & SetAdjacentEdges(bool in_state);
10005 
10009  VisibilityKit & SetHardEdges(bool in_state);
10010 
10014  VisibilityKit & SetMeshQuadEdges(bool in_state);
10015 
10019  VisibilityKit & SetNonCulledEdges(bool in_state);
10020 
10024  VisibilityKit & SetPerimeterEdges(bool in_state);
10025 
10029  VisibilityKit & SetFaces(bool in_state);
10030 
10034  VisibilityKit & SetVertices(bool in_state);
10035 
10039  VisibilityKit & SetMarkers(bool in_state);
10040 
10044  VisibilityKit & SetShadowCasting(bool in_state);
10045 
10049  VisibilityKit & SetShadowReceiving(bool in_state);
10050 
10054  VisibilityKit & SetShadowEmitting(bool in_state);
10055 
10056 
10060  VisibilityKit & SetCutGeometry(bool in_state);
10061 
10065  VisibilityKit & SetEdges(bool in_state);
10066 
10070  VisibilityKit & SetGeometry(bool in_state);
10071 
10075  VisibilityKit & SetLights(bool in_state);
10076 
10080  VisibilityKit & SetShadows(bool in_state);
10081 
10085  VisibilityKit & SetLeaderLines(bool in_state);
10086 
10090  VisibilityKit & SetEverything(bool in_state);
10091 
10092 
10095  VisibilityKit & UnsetCuttingSections();
10096 
10099  VisibilityKit & UnsetCutEdges();
10100 
10103  VisibilityKit & UnsetCutFaces();
10104 
10107  VisibilityKit & UnsetWindows();
10108 
10111  VisibilityKit & UnsetText();
10112 
10115  VisibilityKit & UnsetLines();
10116 
10119  VisibilityKit & UnsetEdgeLights();
10120 
10123  VisibilityKit & UnsetMarkerLights();
10124 
10127  VisibilityKit & UnsetFaceLights();
10128 
10131  VisibilityKit & UnsetGenericEdges();
10132 
10135  VisibilityKit & UnsetInteriorSilhouetteEdges();
10136 
10139  VisibilityKit & UnsetAdjacentEdges();
10140 
10143  VisibilityKit & UnsetHardEdges();
10144 
10147  VisibilityKit & UnsetMeshQuadEdges();
10148 
10151  VisibilityKit & UnsetNonCulledEdges();
10152 
10155  VisibilityKit & UnsetPerimeterEdges();
10156 
10159  VisibilityKit & UnsetFaces();
10160 
10163  VisibilityKit & UnsetVertices();
10164 
10167  VisibilityKit & UnsetMarkers();
10168 
10171  VisibilityKit & UnsetShadowCasting();
10172 
10175  VisibilityKit & UnsetShadowReceiving();
10176 
10179  VisibilityKit & UnsetShadowEmitting();
10180 
10181 
10184  VisibilityKit & UnsetCutGeometry();
10185 
10188  VisibilityKit & UnsetEdges();
10189 
10192  VisibilityKit & UnsetGeometry();
10193 
10196  VisibilityKit & UnsetLights();
10197 
10200  VisibilityKit & UnsetShadows();
10201 
10204  VisibilityKit & UnsetLeaderLines();
10205 
10208  VisibilityKit & UnsetEverything();
10209 
10210 
10214  bool ShowCuttingSections(bool & out_state) const;
10215 
10219  bool ShowCutEdges(bool & out_state) const;
10220 
10224  bool ShowCutFaces(bool & out_state) const;
10225 
10229  bool ShowWindows(bool & out_state) const;
10230 
10234  bool ShowText(bool & out_state) const;
10235 
10239  bool ShowLines(bool & out_state) const;
10240 
10244  bool ShowEdgeLights(bool & out_state) const;
10245 
10249  bool ShowMarkerLights(bool & out_state) const;
10250 
10254  bool ShowFaceLights(bool & out_state) const;
10255 
10259  bool ShowGenericEdges(bool & out_state) const;
10260 
10264  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10265 
10269  bool ShowAdjacentEdges(bool & out_state) const;
10270 
10274  bool ShowHardEdges(bool & out_state) const;
10275 
10279  bool ShowMeshQuadEdges(bool & out_state) const;
10280 
10284  bool ShowNonCulledEdges(bool & out_state) const;
10285 
10289  bool ShowPerimeterEdges(bool & out_state) const;
10290 
10294  bool ShowFaces(bool & out_state) const;
10295 
10299  bool ShowVertices(bool & out_state) const;
10300 
10304  bool ShowMarkers(bool & out_state) const;
10305 
10309  bool ShowShadowCasting(bool & out_state) const;
10310 
10314  bool ShowShadowReceiving(bool & out_state) const;
10315 
10319  bool ShowShadowEmitting(bool & out_state) const;
10320 
10324  bool ShowLeaderLines(bool & out_state) const;
10325 };
10326 
10327 
10333 class HPS_API VisibilityControl : public Control
10334 {
10335 public:
10336 
10338  explicit VisibilityControl(SegmentKey & in_seg);
10339 
10341  VisibilityControl(VisibilityControl const & in_that);
10342 
10347 
10351  VisibilityControl & operator=(VisibilityControl && in_that);
10352 
10354  ~VisibilityControl();
10355 
10356  virtual HPS::Type Type() const { return ObjectType(); }
10357 
10358  HPS::Type ObjectType() const {return HPS::Type::VisibilityControl;};
10359 
10363  VisibilityControl & operator=(VisibilityControl const & in_that);
10364 
10368  VisibilityControl & SetCuttingSections(bool in_state);
10369 
10373  VisibilityControl & SetCutEdges(bool in_state);
10374 
10378  VisibilityControl & SetCutFaces(bool in_state);
10379 
10383  VisibilityControl & SetWindows(bool in_state);
10384 
10388  VisibilityControl & SetText(bool in_state);
10389 
10393  VisibilityControl & SetLines(bool in_state);
10394 
10398  VisibilityControl & SetEdgeLights(bool in_state);
10399 
10403  VisibilityControl & SetMarkerLights(bool in_state);
10404 
10408  VisibilityControl & SetFaceLights(bool in_state);
10409 
10413  VisibilityControl & SetGenericEdges(bool in_state);
10414 
10418  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
10419 
10423  VisibilityControl & SetAdjacentEdges(bool in_state);
10424 
10428  VisibilityControl & SetHardEdges(bool in_state);
10429 
10433  VisibilityControl & SetMeshQuadEdges(bool in_state);
10434 
10438  VisibilityControl & SetNonCulledEdges(bool in_state);
10439 
10443  VisibilityControl & SetPerimeterEdges(bool in_state);
10444 
10448  VisibilityControl & SetFaces(bool in_state);
10449 
10453  VisibilityControl & SetVertices(bool in_state);
10454 
10458  VisibilityControl & SetMarkers(bool in_state);
10459 
10463  VisibilityControl & SetShadowCasting(bool in_state);
10464 
10468  VisibilityControl & SetShadowReceiving(bool in_state);
10469 
10473  VisibilityControl & SetShadowEmitting(bool in_state);
10474 
10475 
10479  VisibilityControl & SetCutGeometry(bool in_state);
10480 
10484  VisibilityControl & SetEdges(bool in_state);
10485 
10489  VisibilityControl & SetGeometry(bool in_state);
10490 
10494  VisibilityControl & SetLights(bool in_state);
10495 
10499  VisibilityControl & SetShadows(bool in_state);
10500 
10504  VisibilityControl & SetLeaderLines(bool in_state);
10505 
10509  VisibilityControl & SetEverything(bool in_state);
10510 
10511 
10515  VisibilityControl & UnsetCuttingSections();
10516 
10520  VisibilityControl & UnsetCutEdges();
10521 
10525  VisibilityControl & UnsetCutFaces();
10526 
10530  VisibilityControl & UnsetWindows();
10531 
10535  VisibilityControl & UnsetText();
10536 
10540  VisibilityControl & UnsetLines();
10541 
10545  VisibilityControl & UnsetEdgeLights();
10546 
10550  VisibilityControl & UnsetMarkerLights();
10551 
10555  VisibilityControl & UnsetFaceLights();
10556 
10560  VisibilityControl & UnsetGenericEdges();
10561 
10565  VisibilityControl & UnsetInteriorSilhouetteEdges();
10566 
10570  VisibilityControl & UnsetAdjacentEdges();
10571 
10575  VisibilityControl & UnsetHardEdges();
10576 
10580  VisibilityControl & UnsetMeshQuadEdges();
10581 
10585  VisibilityControl & UnsetNonCulledEdges();
10586 
10590  VisibilityControl & UnsetPerimeterEdges();
10591 
10595  VisibilityControl & UnsetFaces();
10596 
10600  VisibilityControl & UnsetVertices();
10601 
10605  VisibilityControl & UnsetMarkers();
10606 
10610  VisibilityControl & UnsetShadowCasting();
10611 
10615  VisibilityControl & UnsetShadowReceiving();
10616 
10620  VisibilityControl & UnsetShadowEmitting();
10621 
10622 
10626  VisibilityControl & UnsetCutGeometry();
10627 
10631  VisibilityControl & UnsetEdges();
10632 
10636  VisibilityControl & UnsetGeometry();
10637 
10641  VisibilityControl & UnsetLights();
10642 
10646  VisibilityControl & UnsetShadows();
10647 
10651  VisibilityControl & UnsetLeaderLines();
10652 
10656  VisibilityControl & UnsetEverything();
10657 
10658 
10662  bool ShowCuttingSections(bool & out_state) const;
10663 
10667  bool ShowCutEdges(bool & out_state) const;
10668 
10672  bool ShowCutFaces(bool & out_state) const;
10673 
10677  bool ShowWindows(bool & out_state) const;
10678 
10682  bool ShowText(bool & out_state) const;
10683 
10687  bool ShowLines(bool & out_state) const;
10688 
10692  bool ShowEdgeLights(bool & out_state) const;
10693 
10697  bool ShowMarkerLights(bool & out_state) const;
10698 
10702  bool ShowFaceLights(bool & out_state) const;
10703 
10707  bool ShowGenericEdges(bool & out_state) const;
10708 
10712  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
10713 
10717  bool ShowAdjacentEdges(bool & out_state) const;
10718 
10722  bool ShowHardEdges(bool & out_state) const;
10723 
10727  bool ShowMeshQuadEdges(bool & out_state) const;
10728 
10732  bool ShowNonCulledEdges(bool & out_state) const;
10733 
10737  bool ShowPerimeterEdges(bool & out_state) const;
10738 
10742  bool ShowFaces(bool & out_state) const;
10743 
10747  bool ShowVertices(bool & out_state) const;
10748 
10752  bool ShowMarkers(bool & out_state) const;
10753 
10757  bool ShowShadowCasting(bool & out_state) const;
10758 
10762  bool ShowShadowReceiving(bool & out_state) const;
10763 
10767  bool ShowShadowEmitting(bool & out_state) const;
10768 
10772  bool ShowLeaderLines(bool & out_state) const;
10773 
10774 private:
10777 };
10778 
10779 
10780 
10783 class HPS_API CameraKit : public Kit
10784 {
10785 public:
10786 
10788  CameraKit();
10789 
10792  CameraKit(const CameraKit & in_kit);
10793 
10797  CameraKit(CameraKit && in_that);
10798 
10802  CameraKit & operator=(CameraKit && in_that);
10803 
10805  virtual ~CameraKit();
10806 
10807  HPS::Type ObjectType() const {return HPS::Type::CameraKit;};
10808 
10812  static CameraKit GetDefault();
10813 
10816  void Set(CameraKit const & in_kit);
10817 
10820  void Show(CameraKit & out_kit) const;
10821 
10825  CameraKit & operator=(CameraKit const & in_kit);
10826 
10829  bool Empty() const;
10830 
10834  bool Equals(CameraKit const & in_kit) const;
10835 
10839  bool operator==(CameraKit const & in_kit) const;
10840 
10844  bool operator!=(CameraKit const & in_kit) const;
10845 
10849  CameraKit & SetUpVector(Vector const & in_up);
10850 
10854  CameraKit & SetPosition(Point const & in_position);
10855 
10859  CameraKit & SetTarget(Point const & in_target);
10860 
10867  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
10868 
10874  CameraKit & SetField(float in_width, float in_height);
10875 
10885  CameraKit & SetNearLimit(float const in_limit);
10886 
10889  CameraKit & UnsetUpVector();
10890 
10893  CameraKit & UnsetPosition();
10894 
10897  CameraKit & UnsetTarget();
10898 
10901  CameraKit & UnsetProjection();
10902 
10905  CameraKit & UnsetField();
10906 
10909  CameraKit & UnsetNearLimit();
10910 
10913  CameraKit & UnsetEverything();
10914 
10915 
10919  bool ShowUpVector(Vector & out_up_vector) const;
10920 
10924  bool ShowPosition(Point & out_position) const;
10925 
10929  bool ShowTarget(Point & out_target) const;
10930 
10934  bool ShowProjection(Camera::Projection & out_type) const;
10935 
10941  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
10942 
10946  bool ShowWidth(float & out_width) const;
10947 
10951  bool ShowHeight(float & out_height) const;
10952 
10957  bool ShowField(float & out_width, float & out_height) const;
10958 
10962  bool ShowNearLimit(float & out_near_limit) const;
10963 
10970  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
10971 
10978  CameraKit & Orbit(float in_theta, float in_phi);
10979 
10986  CameraKit & Pan(float in_theta, float in_phi);
10987 
10993  CameraKit & Roll(float in_theta);
10994 
11000  CameraKit & Zoom(float in_zoom);
11001 };
11002 
11006 class HPS_API CameraControl : public Control
11007 {
11008 public:
11010  explicit CameraControl(SegmentKey & in_seg);
11011 
11013  CameraControl(CameraControl const & in_that);
11014 
11018  CameraControl(CameraControl && in_that);
11019 
11023  CameraControl & operator=(CameraControl && in_that);
11024 
11026  ~CameraControl();
11027 
11028  virtual HPS::Type Type() const { return ObjectType(); }
11029 
11030  HPS::Type ObjectType() const {return HPS::Type::CameraControl;};
11031 
11035  CameraControl & operator=(CameraControl const & in_that);
11036 
11041  CameraControl & SetUpVector(Vector const & in_up);
11042 
11047  CameraControl & SetPosition(Point const & in_position);
11048 
11053  CameraControl & SetTarget(Point const & in_target);
11054 
11061  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
11062 
11068  CameraControl & SetField(float in_width, float in_height);
11069 
11080  CameraControl & SetNearLimit(float in_double);
11081 
11086  CameraControl & UnsetEverything();
11087 
11088 
11092  bool ShowUpVector(Vector & out_up_vector) const;
11093 
11097  bool ShowPosition(Point & out_position) const;
11098 
11102  bool ShowTarget(Point & out_target) const;
11103 
11107  bool ShowProjection(Camera::Projection & out_type) const;
11108 
11114  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
11115 
11119  bool ShowWidth(float & out_width) const;
11120 
11124  bool ShowHeight(float & out_height) const;
11125 
11130  bool ShowField(float & out_width, float & out_height) const;
11131 
11135  bool ShowNearLimit(float & out_near_limit) const;
11136 
11143  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
11144 
11151  CameraControl & Orbit(float in_theta, float in_phi);
11152 
11159  CameraControl & Pan(float in_theta, float in_phi);
11160 
11166  CameraControl & Roll(float in_theta);
11167 
11173  CameraControl & Zoom(float in_zoom);
11174 
11175 private:
11177  CameraControl();
11178 };
11179 
11180 
11181 
11183 class HPS_API SelectabilityKit : public Kit
11184 {
11185 public:
11186 
11188  SelectabilityKit();
11189 
11192  SelectabilityKit(SelectabilityKit const & in_kit);
11193 
11197  SelectabilityKit(SelectabilityKit && in_that);
11198 
11202  SelectabilityKit & operator=(SelectabilityKit && in_that);
11203 
11205  virtual ~SelectabilityKit();
11206 
11207  HPS::Type ObjectType() const {return HPS::Type::SelectabilityKit;};
11208 
11212  static SelectabilityKit GetDefault();
11213 
11216  void Set(SelectabilityKit const & in_kit);
11217 
11220  void Show(SelectabilityKit & out_kit) const;
11221 
11225  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
11226 
11229  bool Empty() const;
11230 
11234  bool Equals(SelectabilityKit const & in_kit) const;
11235 
11239  bool operator==(SelectabilityKit const & in_kit) const;
11240 
11244  bool operator!=(SelectabilityKit const & in_kit) const;
11245 
11246 
11250  SelectabilityKit & SetWindows(Selectability::Value in_val);
11251 
11255  SelectabilityKit & SetWindows(bool in_val);
11256 
11260  SelectabilityKit & SetEdges(Selectability::Value in_val);
11261 
11265  SelectabilityKit & SetEdges(bool in_val);
11266 
11270  SelectabilityKit & SetFaces(Selectability::Value in_val);
11271 
11275  SelectabilityKit & SetFaces(bool in_val);
11276 
11280  SelectabilityKit & SetLights(Selectability::Value in_val);
11281 
11285  SelectabilityKit & SetLights(bool in_val);
11286 
11290  SelectabilityKit & SetLines(Selectability::Value in_val);
11291 
11295  SelectabilityKit & SetLines(bool in_val);
11296 
11300  SelectabilityKit & SetMarkers(Selectability::Value in_val);
11301 
11305  SelectabilityKit & SetMarkers(bool in_val);
11306 
11310  SelectabilityKit & SetVertices(Selectability::Value in_val);
11311 
11315  SelectabilityKit & SetVertices(bool in_val);
11316 
11320  SelectabilityKit & SetText(Selectability::Value in_val);
11321 
11325  SelectabilityKit & SetText(bool in_val);
11326 
11330  SelectabilityKit & SetGeometry(Selectability::Value in_val);
11331 
11335  SelectabilityKit & SetGeometry(bool in_val);
11336 
11340  SelectabilityKit & SetEverything(Selectability::Value in_val);
11341 
11345  SelectabilityKit & SetEverything(bool in_val);
11346 
11347 
11350  SelectabilityKit & UnsetWindows();
11351 
11354  SelectabilityKit & UnsetEdges();
11355 
11358  SelectabilityKit & UnsetFaces();
11359 
11362  SelectabilityKit & UnsetLights();
11363 
11366  SelectabilityKit & UnsetLines();
11367 
11370  SelectabilityKit & UnsetMarkers();
11371 
11374  SelectabilityKit & UnsetVertices();
11375 
11378  SelectabilityKit & UnsetText();
11379 
11382  SelectabilityKit & UnsetGeometry();
11383 
11386  SelectabilityKit & UnsetEverything();
11387 
11388 
11392  bool ShowWindows(Selectability::Value & out_val) const;
11393 
11397  bool ShowEdges(Selectability::Value & out_val) const;
11398 
11402  bool ShowFaces(Selectability::Value & out_val) const;
11403 
11407  bool ShowLights(Selectability::Value & out_val) const;
11408 
11412  bool ShowLines(Selectability::Value & out_val) const;
11413 
11417  bool ShowMarkers(Selectability::Value & out_val) const;
11418 
11422  bool ShowVertices(Selectability::Value & out_val) const;
11423 
11427  bool ShowText(Selectability::Value & out_val) const;
11428 };
11429 
11435 class HPS_API SelectabilityControl : public Control
11436 {
11437 public:
11438 
11440  explicit SelectabilityControl(SegmentKey & in_seg);
11441 
11443  SelectabilityControl(SelectabilityControl const & in_that);
11444 
11449 
11453  SelectabilityControl & operator=(SelectabilityControl && in_that);
11454 
11457 
11458  virtual HPS::Type Type() const { return ObjectType(); }
11459 
11460  HPS::Type ObjectType() const {return HPS::Type::SelectabilityControl;};
11461 
11465  SelectabilityControl & operator=(SelectabilityControl const & in_that);
11466 
11470  SelectabilityControl & SetWindows(Selectability::Value in_val);
11471 
11475  SelectabilityControl & SetWindows(bool in_val);
11476 
11480  SelectabilityControl & SetEdges(Selectability::Value in_val);
11481 
11485  SelectabilityControl & SetEdges(bool in_val);
11486 
11490  SelectabilityControl & SetFaces(Selectability::Value in_val);
11491 
11495  SelectabilityControl & SetFaces(bool in_val);
11496 
11500  SelectabilityControl & SetLights(Selectability::Value in_val);
11501 
11505  SelectabilityControl & SetLights(bool in_val);
11506 
11510  SelectabilityControl & SetLines(Selectability::Value in_val);
11511 
11515  SelectabilityControl & SetLines(bool in_val);
11516 
11520  SelectabilityControl & SetMarkers(Selectability::Value in_val);
11521 
11525  SelectabilityControl & SetMarkers(bool in_val);
11526 
11530  SelectabilityControl & SetVertices(Selectability::Value in_val);
11531 
11535  SelectabilityControl & SetVertices(bool in_val);
11536 
11540  SelectabilityControl & SetText(Selectability::Value in_val);
11541 
11545  SelectabilityControl & SetText(bool in_val);
11546 
11550  SelectabilityControl & SetGeometry(Selectability::Value in_val);
11551 
11555  SelectabilityControl & SetGeometry(bool in_val);
11556 
11560  SelectabilityControl & SetEverything(Selectability::Value in_val);
11561 
11565  SelectabilityControl & SetEverything(bool in_val);
11566 
11567 
11571  SelectabilityControl & UnsetWindows();
11572 
11576  SelectabilityControl & UnsetEdges();
11577 
11581  SelectabilityControl & UnsetFaces();
11582 
11586  SelectabilityControl & UnsetLights();
11587 
11591  SelectabilityControl & UnsetLines();
11592 
11596  SelectabilityControl & UnsetMarkers();
11597 
11601  SelectabilityControl & UnsetVertices();
11602 
11606  SelectabilityControl & UnsetText();
11607 
11611  SelectabilityControl & UnsetGeometry();
11612 
11616  SelectabilityControl & UnsetEverything();
11617 
11618 
11622  bool ShowWindows(Selectability::Value & out_val) const;
11623 
11627  bool ShowEdges(Selectability::Value & out_val) const;
11628 
11632  bool ShowFaces(Selectability::Value & out_val) const;
11633 
11637  bool ShowLights(Selectability::Value & out_val) const;
11638 
11642  bool ShowLines(Selectability::Value & out_val) const;
11643 
11647  bool ShowMarkers(Selectability::Value & out_val) const;
11648 
11652  bool ShowVertices(Selectability::Value & out_val) const;
11653 
11657  bool ShowText(Selectability::Value & out_val) const;
11658 
11659 private:
11662 };
11663 
11664 
11666 class HPS_API TransparencyKit : public Kit
11667 {
11668 public:
11669 
11671  TransparencyKit();
11672 
11675  TransparencyKit(TransparencyKit const & in_kit);
11676 
11680  TransparencyKit(TransparencyKit && in_that);
11681 
11685  TransparencyKit & operator=(TransparencyKit && in_that);
11686 
11688  virtual ~TransparencyKit();
11689 
11690  HPS::Type ObjectType() const {return HPS::Type::TransparencyKit;};
11691 
11695  static TransparencyKit GetDefault();
11696 
11699  void Set(TransparencyKit const & in_kit);
11700 
11703  void Show(TransparencyKit & out_kit) const;
11704 
11708  TransparencyKit & operator=(TransparencyKit const & in_kit);
11709 
11712  bool Empty() const;
11713 
11717  bool Equals(TransparencyKit const & in_kit) const;
11718 
11722  bool operator==(TransparencyKit const & in_kit) const;
11723 
11727  bool operator!=(TransparencyKit const & in_kit) const;
11728 
11729 
11733  TransparencyKit & SetMethod(Transparency::Method in_style);
11734 
11738  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
11739 
11745  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
11746 
11751  TransparencyKit & SetDepthPeelingPreference(Transparency::Preference in_preference);
11752 
11758  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11759 
11764  TransparencyKit & SetDepthWriting(bool in_state);
11765 
11766 
11769  TransparencyKit & UnsetMethod();
11770 
11773  TransparencyKit & UnsetAlgorithm();
11774 
11777  TransparencyKit & UnsetDepthPeelingLayers();
11778 
11781  TransparencyKit & UnsetDepthPeelingMinimumArea();
11782 
11785  TransparencyKit & UnsetDepthWriting();
11786 
11789  TransparencyKit & UnsetDepthPeelingPreference();
11790 
11793  TransparencyKit & UnsetEverything();
11794 
11795 
11799  bool ShowMethod(Transparency::Method & out_style) const;
11800 
11804  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11805 
11809  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11810 
11815  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11816 
11820  bool ShowDepthWriting(bool & out_state) const;
11821 
11825  bool ShowDepthPeelingPreference(Transparency::Preference & out_preference) const;
11826 };
11827 
11833 class HPS_API TransparencyControl : public Control
11834 {
11835 public:
11836 
11838  explicit TransparencyControl(SegmentKey & in_seg);
11839 
11841  TransparencyControl(TransparencyControl const & in_that);
11842 
11847 
11851  TransparencyControl & operator=(TransparencyControl && in_that);
11852 
11855 
11856  virtual HPS::Type Type() const { return ObjectType(); }
11857 
11858  HPS::Type ObjectType() const {return HPS::Type::TransparencyControl;};
11859 
11863  TransparencyControl & operator=(TransparencyControl const & in_that);
11864 
11868  TransparencyControl & SetMethod(Transparency::Method in_style);
11869 
11873  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
11874 
11880  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
11881 
11887  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
11888 
11893  TransparencyControl & SetDepthWriting(bool in_state);
11894 
11899  TransparencyControl & SetDepthPeelingPreference(Transparency::Preference in_preference);
11900 
11904  TransparencyControl & UnsetMethod();
11905 
11909  TransparencyControl & UnsetAlgorithm();
11910 
11914  TransparencyControl & UnsetDepthPeelingLayers();
11915 
11919  TransparencyControl & UnsetDepthPeelingMinimumArea();
11920 
11924  TransparencyControl & UnsetDepthWriting();
11925 
11929  TransparencyControl & UnsetDepthPeelingPreference();
11930 
11934  TransparencyControl & UnsetEverything();
11935 
11939  bool ShowMethod(Transparency::Method & out_style) const;
11940 
11944  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
11945 
11949  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
11950 
11955  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
11956 
11960  bool ShowDepthWriting(bool & out_state) const;
11961 
11965  bool ShowDepthPeelingPreference(Transparency::Preference & out_preference) const;
11966 
11967 private:
11970 };
11971 
11973 class HPS_API ColorInterpolationKit : public Kit
11974 {
11975 public:
11976 
11979 
11982 
11987 
11991  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
11992 
11994  virtual ~ColorInterpolationKit();
11995 
11996  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationKit;};
11997 
11998  static ColorInterpolationKit GetDefault();
11999 
12001  void Set(ColorInterpolationKit const & in_kit);
12002 
12004  void Show(ColorInterpolationKit & out_kit) const;
12005 
12007  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
12008 
12010  bool Empty() const;
12011 
12013  bool Equals(ColorInterpolationKit const & in_kit) const;
12014 
12016  bool operator==(ColorInterpolationKit const & in_kit) const;
12017 
12019  bool operator!=(ColorInterpolationKit const & in_kit) const;
12020 
12021 
12025  ColorInterpolationKit & SetFaceColor(bool in_state);
12026 
12030  ColorInterpolationKit & SetEdgeColor(bool in_state);
12031 
12035  ColorInterpolationKit & SetVertexColor(bool in_state);
12036 
12040  ColorInterpolationKit & SetFaceIndex(bool in_state);
12041 
12045  ColorInterpolationKit & SetEdgeIndex(bool in_state);
12046 
12050  ColorInterpolationKit & SetVertexIndex(bool in_state);
12051 
12052 
12055  ColorInterpolationKit & UnsetFaceColor();
12056 
12059  ColorInterpolationKit & UnsetEdgeColor();
12060 
12063  ColorInterpolationKit & UnsetVertexColor();
12064 
12067  ColorInterpolationKit & UnsetFaceIndex();
12068 
12071  ColorInterpolationKit & UnsetEdgeIndex();
12072 
12075  ColorInterpolationKit & UnsetVertexIndex();
12076 
12079  ColorInterpolationKit & UnsetEverything();
12080 
12081 
12085  bool ShowFaceColor(bool & out_state) const;
12086 
12090  bool ShowEdgeColor(bool & out_state) const;
12091 
12095  bool ShowVertexColor(bool & out_state) const;
12096 
12100  bool ShowFaceIndex(bool & out_state) const;
12101 
12105  bool ShowEdgeIndex(bool & out_state) const;
12106 
12110  bool ShowVertexIndex(bool & out_state) const;
12111 };
12112 
12113 
12117 class HPS_API ColorInterpolationControl : public Control
12118 {
12119 public:
12120 
12122  explicit ColorInterpolationControl(SegmentKey & in_seg);
12123 
12126 
12131 
12135  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
12136 
12139 
12140  virtual HPS::Type Type() const { return ObjectType(); }
12141 
12142  HPS::Type ObjectType() const {return HPS::Type::ColorInterpolationControl;};
12143 
12147  ColorInterpolationControl & operator=(ColorInterpolationControl const & in_that);
12148 
12152  ColorInterpolationControl & SetFaceColor(bool in_state);
12153 
12157  ColorInterpolationControl & SetEdgeColor(bool in_state);
12158 
12162  ColorInterpolationControl & SetVertexColor(bool in_state);
12163 
12167  ColorInterpolationControl & SetFaceIndex(bool in_state);
12168 
12172  ColorInterpolationControl & SetEdgeIndex(bool in_state);
12173 
12177  ColorInterpolationControl & SetVertexIndex(bool in_state);
12178 
12179 
12183  ColorInterpolationControl & UnsetFaceColor();
12184 
12188  ColorInterpolationControl & UnsetEdgeColor();
12189 
12193  ColorInterpolationControl & UnsetVertexColor();
12194 
12198  ColorInterpolationControl & UnsetFaceIndex();
12199 
12203  ColorInterpolationControl & UnsetEdgeIndex();
12204 
12208  ColorInterpolationControl & UnsetVertexIndex();
12209 
12213  ColorInterpolationControl & UnsetEverything();
12214 
12215 
12219  bool ShowFaceColor(bool & out_state) const;
12220 
12224  bool ShowEdgeColor(bool & out_state) const;
12225 
12229  bool ShowVertexColor(bool & out_state) const;
12230 
12234  bool ShowFaceIndex(bool & out_state) const;
12235 
12239  bool ShowEdgeIndex(bool & out_state) const;
12240 
12244  bool ShowVertexIndex(bool & out_state) const;
12245 
12246 private:
12249 };
12250 
12251 
12253 class HPS_API CullingKit : public Kit
12254 {
12255 public:
12256 
12258  CullingKit();
12259 
12262  CullingKit(CullingKit const & in_kit);
12263 
12267  CullingKit(CullingKit && in_that);
12268 
12272  CullingKit & operator=(CullingKit && in_that);
12273 
12275  virtual ~CullingKit();
12276 
12277  HPS::Type ObjectType() const {return HPS::Type::CullingKit;};
12278 
12282  static CullingKit GetDefault();
12283 
12286  void Set(CullingKit const & in_kit);
12287 
12290  void Show(CullingKit & out_kit) const;
12291 
12295  CullingKit & operator=(CullingKit const & in_kit);
12296 
12299  bool Empty() const;
12300 
12304  bool Equals(CullingKit const & in_kit) const;
12305 
12309  bool operator==(CullingKit const & in_kit) const;
12310 
12314  bool operator!=(CullingKit const & in_kit) const;
12315 
12320  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
12321 
12326  CullingKit & SetDeferralExtent(unsigned int in_pixels);
12327 
12332  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
12333 
12338  CullingKit & SetExtent(unsigned int in_pixels);
12339 
12343  CullingKit & SetBackFace(bool in_state);
12344 
12351  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
12352 
12359  CullingKit & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
12360 
12367  CullingKit & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
12368 
12374  CullingKit & SetVector(HPS::Vector const & in_vector);
12375 
12379  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
12380 
12384  CullingKit & SetFrustum(bool in_state);
12385 
12388  CullingKit & UnsetDeferralExtent();
12389 
12392  CullingKit & UnsetExtent();
12393 
12396  CullingKit & UnsetBackFace();
12397 
12400  CullingKit & UnsetVector();
12401 
12404  CullingKit & UnsetVectorTolerance();
12405 
12408  CullingKit & UnsetFrustum();
12409 
12412  CullingKit & UnsetEverything();
12413 
12418  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12419 
12424  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12425 
12429  bool ShowBackFace(bool & out_state) const;
12430 
12436  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
12437 
12441  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
12442 
12446  bool ShowFrustum(bool & out_state) const;
12447 };
12448 
12452 class HPS_API CullingControl : public Control
12453 {
12454 public:
12455 
12457  explicit CullingControl(SegmentKey & in_seg);
12458 
12460  CullingControl(CullingControl const & in_that);
12461 
12463  ~CullingControl();
12464 
12468  CullingControl(CullingControl && in_that);
12469 
12473  CullingControl & operator=(CullingControl && in_that);
12474 
12475  virtual HPS::Type Type() const { return ObjectType(); }
12476 
12477  HPS::Type ObjectType() const {return HPS::Type::CullingControl;};
12478 
12482  CullingControl & operator=(CullingControl const & in_that);
12483 
12490  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
12491 
12498  CullingControl & SetDeferralExtent(unsigned int in_pixels);
12499 
12504  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
12505 
12510  CullingControl & SetExtent(unsigned int in_pixels);
12511 
12516  CullingControl & SetBackFace(bool in_state);
12517 
12524  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector, float in_tolerance_degrees);
12525 
12532  CullingControl & SetVector(HPS::Vector const & in_vector, float in_tolerance_degrees);
12533 
12540  CullingControl & SetVector(bool in_state, HPS::Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
12541 
12547  CullingControl & SetVector(HPS::Vector const & in_vector);
12548 
12552  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
12553 
12557  CullingControl & SetFrustum(bool in_state);
12558 
12562  CullingControl & UnsetDeferralExtent();
12563 
12567  CullingControl & UnsetExtent();
12568 
12572  CullingControl & UnsetBackFace();
12573 
12577  CullingControl & UnsetVector();
12578 
12582  CullingControl & UnsetVectorTolerance();
12583 
12587  CullingControl & UnsetFrustum();
12588 
12592  CullingControl & UnsetEverything();
12593 
12598  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
12599 
12604  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
12605 
12609  bool ShowBackFace(bool & out_state) const;
12610 
12616  bool ShowVector(bool & out_state, HPS::Vector & out_vector) const;
12617 
12621  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
12622 
12626  bool ShowFrustum(bool & out_state) const;
12627 
12628 private:
12630  CullingControl();
12631 };
12632 
12633 
12634 
12635 
12637 class HPS_API MarkerAttributeKit : public Kit
12638 {
12639 public:
12640 
12643 
12646  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
12647 
12652 
12656  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
12657 
12659  virtual ~MarkerAttributeKit();
12660 
12661  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeKit;};
12662 
12666  static MarkerAttributeKit GetDefault();
12667 
12670  void Set(MarkerAttributeKit const & in_kit);
12671 
12674  void Show(MarkerAttributeKit & out_kit) const;
12675 
12679  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
12680 
12683  bool Empty() const;
12684 
12688  bool Equals(MarkerAttributeKit const & in_kit) const;
12689 
12693  bool operator==(MarkerAttributeKit const & in_kit) const;
12694 
12698  bool operator!=(MarkerAttributeKit const & in_kit) const;
12699 
12700 
12704  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
12705 
12710  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12711 
12712 
12715  MarkerAttributeKit & UnsetSymbol();
12716 
12719  MarkerAttributeKit & UnsetSize();
12720 
12723  MarkerAttributeKit & UnsetEverything();
12724 
12725 
12729  bool ShowSymbol(UTF8 & out_glyph_name) const;
12730 
12735  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12736 };
12737 
12743 class HPS_API MarkerAttributeControl : public Control
12744 {
12745 public:
12746 
12748  explicit MarkerAttributeControl(SegmentKey & in_seg);
12749 
12752 
12757 
12761  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
12762 
12765 
12766  virtual HPS::Type Type() const { return ObjectType(); }
12767 
12768  HPS::Type ObjectType() const {return HPS::Type::MarkerAttributeControl;};
12769 
12773  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
12774 
12778  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
12779 
12784  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
12785 
12786 
12790  MarkerAttributeControl & UnsetSymbol();
12791 
12795  MarkerAttributeControl & UnsetSize();
12796 
12800  MarkerAttributeControl & UnsetEverything();
12801 
12802 
12806  bool ShowSymbol(UTF8 & out_glyph_name) const;
12807 
12812  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
12813 
12814 private:
12817 };
12818 
12819 
12821 class HPS_API SphereAttributeKit : public Kit
12822 {
12823 public:
12824 
12827 
12830  SphereAttributeKit(SphereAttributeKit const & in_kit);
12831 
12836 
12840  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
12841 
12843  virtual ~SphereAttributeKit();
12844 
12845  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeKit;};
12846 
12850  static SphereAttributeKit GetDefault();
12851 
12854  void Set(SphereAttributeKit const & in_kit);
12855 
12858  void Show(SphereAttributeKit & out_kit) const;
12859 
12863  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
12864 
12867  bool Empty() const;
12868 
12872  bool Equals(SphereAttributeKit const & in_kit) const;
12873 
12877  bool operator==(SphereAttributeKit const & in_kit) const;
12878 
12882  bool operator!=(SphereAttributeKit const & in_kit) const;
12883 
12884 
12888  SphereAttributeKit & SetTessellation(size_t in_facets);
12889 
12890 
12893  SphereAttributeKit & UnsetTessellation();
12894 
12897  SphereAttributeKit & UnsetEverything();
12898 
12899 
12903  bool ShowTessellation(size_t & out_facets) const;
12904 };
12905 
12906 
12909 class HPS_API SphereAttributeControl : public Control
12910 {
12911 public:
12912 
12914  explicit SphereAttributeControl(SegmentKey const & in_seg);
12915 
12918 
12923 
12927  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
12928 
12931 
12932  virtual HPS::Type Type() const { return ObjectType(); }
12933 
12934  HPS::Type ObjectType() const {return HPS::Type::SphereAttributeControl;};
12935 
12939  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
12940 
12945  SphereAttributeControl & SetTessellation(size_t in_facets);
12946 
12947 
12951  SphereAttributeControl & UnsetTessellation();
12952 
12956  SphereAttributeControl & UnsetEverything();
12957 
12958 
12962  bool ShowTessellation(size_t & out_facets) const;
12963 
12964 private:
12967 };
12968 
12969 
12971 class HPS_API LightingAttributeKit : public Kit
12972 {
12973 public:
12974 
12977 
12981 
12986 
12990  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
12991 
12993  virtual ~LightingAttributeKit();
12994 
12995  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeKit;};
12996 
13000  static LightingAttributeKit GetDefault();
13001 
13004  void Set(LightingAttributeKit const & in_kit);
13005 
13008  void Show(LightingAttributeKit & out_kit) const;
13009 
13013  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
13014 
13017  bool Empty() const;
13018 
13022  bool Equals(LightingAttributeKit const & in_kit) const;
13023 
13027  bool operator==(LightingAttributeKit const & in_kit) const;
13028 
13032  bool operator!=(LightingAttributeKit const & in_kit) const;
13033 
13034 
13038  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
13039 
13040 
13043  LightingAttributeKit & UnsetInterpolationAlgorithm();
13044 
13047  LightingAttributeKit & UnsetEverything();
13048 
13049 
13053  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
13054 };
13055 
13056 
13057 
13063 class HPS_API LightingAttributeControl : public Control
13064 {
13065 public:
13066 
13068  explicit LightingAttributeControl(SegmentKey & in_seg);
13069 
13072 
13077 
13081  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
13082 
13085 
13086  virtual HPS::Type Type() const { return ObjectType(); }
13087 
13088  HPS::Type ObjectType() const {return HPS::Type::LightingAttributeControl;};
13089 
13093  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
13094 
13098  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
13099 
13100 
13104  LightingAttributeControl & UnsetInterpolationAlgorithm();
13105 
13109  LightingAttributeControl & UnsetEverything();
13110 
13111 
13115  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
13116 
13117 private:
13120 };
13121 
13122 
13123 
13125 class HPS_API CylinderAttributeKit : public Kit
13126 {
13127 public:
13128 
13131 
13135 
13140 
13144  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
13145 
13147  virtual ~CylinderAttributeKit();
13148 
13149  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeKit;};
13150 
13154  static CylinderAttributeKit GetDefault();
13155 
13158  void Set(CylinderAttributeKit const & in_kit);
13159 
13162  void Show(CylinderAttributeKit & out_kit) const;
13163 
13167  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
13168 
13171  bool Empty() const;
13172 
13176  bool Equals(CylinderAttributeKit const & in_kit) const;
13177 
13181  bool operator==(CylinderAttributeKit const & in_kit) const;
13182 
13186  bool operator!=(CylinderAttributeKit const & in_kit) const;
13187 
13188 
13192  CylinderAttributeKit & SetTessellation(size_t in_facets);
13193 
13198  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
13199 
13200 
13203  CylinderAttributeKit & UnsetTessellation();
13204 
13207  CylinderAttributeKit & UnsetOrientation();
13208 
13211  CylinderAttributeKit & UnsetEverything();
13212 
13213 
13217  bool ShowTessellation(size_t & out_facets) const;
13218 
13222  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
13223 };
13224 
13225 
13226 
13230 class HPS_API CylinderAttributeControl : public Control
13231 {
13232 public:
13233 
13235  explicit CylinderAttributeControl(SegmentKey & in_seg);
13236 
13239 
13244 
13248  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
13249 
13252 
13253  virtual HPS::Type Type() const { return ObjectType(); }
13254 
13255  HPS::Type ObjectType() const {return HPS::Type::CylinderAttributeControl;};
13256 
13260  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
13261 
13265  CylinderAttributeControl & SetTessellation(size_t in_facets);
13266 
13271  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
13272 
13273 
13277  CylinderAttributeControl & UnsetTessellation();
13278 
13282  CylinderAttributeControl & UnsetOrientation();
13283 
13287  CylinderAttributeControl & UnsetEverything();
13288 
13289 
13293  bool ShowTessellation(size_t & out_facets) const;
13294 
13298  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
13299 
13300 private:
13303 };
13304 
13305 
13306 
13308 class HPS_API CuttingSectionAttributeKit : public Kit
13309 {
13310 public:
13311 
13314 
13318 
13323 
13328 
13330  virtual ~CuttingSectionAttributeKit();
13331 
13332  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeKit;};
13333 
13337  static CuttingSectionAttributeKit GetDefault();
13338 
13341  void Set(CuttingSectionAttributeKit const & in_kit);
13342 
13345  void Show(CuttingSectionAttributeKit & out_kit) const;
13346 
13350  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
13351 
13354  bool Empty() const;
13355 
13359  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
13360 
13364  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
13365 
13369  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
13370 
13375  CuttingSectionAttributeKit & SetEdgeWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13376 
13381  CuttingSectionAttributeKit & SetTolerance(float in_tolerance, CuttingSection::ToleranceUnits in_units);
13382 
13386  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
13387 
13391  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
13392 
13396  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
13397 
13400  CuttingSectionAttributeKit & UnsetEdgeWeight();
13401 
13404  CuttingSectionAttributeKit & UnsetTolerance();
13405 
13408  CuttingSectionAttributeKit & UnsetCuttingLevel();
13409 
13412  CuttingSectionAttributeKit & UnsetCappingLevel();
13413 
13416  CuttingSectionAttributeKit & UnsetMaterialPreference();
13417 
13420  CuttingSectionAttributeKit & UnsetEverything();
13421 
13422 
13426  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
13427 
13431  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
13432 
13436  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
13437 
13442  bool ShowEdgeWeight(float & out_weight, Line::SizeUnits & out_units) const;
13443 
13448  bool ShowTolerance(float & out_tolerance, CuttingSection::ToleranceUnits & out_units) const;
13449 };
13450 
13451 
13452 
13457 {
13458 public:
13459 
13461  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
13462 
13465 
13470 
13475 
13478 
13479  virtual HPS::Type Type() const { return ObjectType(); }
13480 
13481  HPS::Type ObjectType() const {return HPS::Type::CuttingSectionAttributeControl;};
13482 
13487 
13492  CuttingSectionAttributeControl & SetEdgeWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13493 
13498  CuttingSectionAttributeControl & SetTolerance(float in_tolerance, CuttingSection::ToleranceUnits in_units);
13499 
13504 
13509 
13513  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
13514 
13518  CuttingSectionAttributeControl & UnsetEdgeWeight();
13519 
13523  CuttingSectionAttributeControl & UnsetTolerance();
13524 
13525 
13529  CuttingSectionAttributeControl & UnsetCuttingLevel();
13530 
13534  CuttingSectionAttributeControl & UnsetCappingLevel();
13535 
13539  CuttingSectionAttributeControl & UnsetMaterialPreference();
13540 
13544  CuttingSectionAttributeControl & UnsetEverything();
13545 
13546 
13550  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
13551 
13555  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
13556 
13560  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
13561 
13566  bool ShowEdgeWeight(float & out_weight, Line::SizeUnits & out_units) const;
13567 
13572  bool ShowTolerance(float & out_tolerance, CuttingSection::ToleranceUnits & out_units) const;
13573 
13574 private:
13577 };
13578 
13579 
13580 
13582 class HPS_API TextAttributeKit : public Kit
13583 {
13584 public:
13585 
13587  TextAttributeKit();
13588 
13591  TextAttributeKit(TextAttributeKit const & in_kit);
13592 
13596  TextAttributeKit(TextAttributeKit && in_that);
13597 
13601  TextAttributeKit & operator=(TextAttributeKit && in_that);
13602 
13604  virtual ~TextAttributeKit();
13605 
13606  HPS::Type ObjectType() const {return HPS::Type::TextAttributeKit;};
13607 
13611  static TextAttributeKit GetDefault();
13612 
13615  void Set(TextAttributeKit const & in_kit);
13616 
13619  void Show(TextAttributeKit & out_kit) const;
13620 
13624  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
13625 
13628  bool Empty() const;
13629 
13633  bool Equals(TextAttributeKit const & in_kit) const;
13634 
13638  bool operator==(TextAttributeKit const & in_kit) const;
13639 
13643  bool operator!=(TextAttributeKit const & in_kit) const;
13644 
13645 
13652 
13657  TextAttributeKit & SetBold(bool in_state);
13658 
13663  TextAttributeKit & SetItalic(bool in_state);
13664 
13668  TextAttributeKit & SetOverline(bool in_state);
13669 
13673  TextAttributeKit & SetStrikethrough(bool in_state);
13674 
13678  TextAttributeKit & SetUnderline(bool in_state);
13679 
13685  TextAttributeKit & SetSlant(float in_angle);
13686 
13691  TextAttributeKit & SetLineSpacing(float in_multiplier);
13692 
13697  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
13698 
13703  TextAttributeKit & SetRotation(float in_angle);
13704 
13710  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
13711 
13717  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
13718 
13725  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
13726 
13733 
13743  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
13744 
13754  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
13755 
13760  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
13761 
13768  TextAttributeKit & SetFont(char const * in_name);
13769 
13773  TextAttributeKit & SetTransform(Text::Transform in_trans);
13774 
13778  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
13779 
13784  TextAttributeKit & SetPreference(Text::Preference in_pref);
13785 
13793  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
13794 
13799  TextAttributeKit & SetPath(Vector const & in_path);
13800 
13808  TextAttributeKit & SetSpacing(float in_multiplier);
13809 
13814  TextAttributeKit & SetBackground(bool in_state, char const * in_name);
13815 
13820  TextAttributeKit & SetBackground(char const * in_name);
13821 
13825  TextAttributeKit & SetBackground(bool in_state);
13826 
13831  TextAttributeKit & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
13832 
13838  TextAttributeKit & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
13839 
13846  TextAttributeKit & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
13847 
13852  TextAttributeKit & SetBackgroundStyle(char const * in_name);
13853 
13854 
13857  TextAttributeKit & UnsetAlignment();
13858 
13861  TextAttributeKit & UnsetBold();
13862 
13865  TextAttributeKit & UnsetItalic();
13866 
13869  TextAttributeKit & UnsetOverline();
13870 
13873  TextAttributeKit & UnsetStrikethrough();
13874 
13877  TextAttributeKit & UnsetUnderline();
13878 
13881  TextAttributeKit & UnsetSlant();
13882 
13885  TextAttributeKit & UnsetLineSpacing();
13886 
13889  TextAttributeKit & UnsetRotation();
13890 
13893  TextAttributeKit & UnsetExtraSpace();
13894 
13897  TextAttributeKit & UnsetGreeking();
13898 
13901  TextAttributeKit & UnsetSizeTolerance();
13902 
13905  TextAttributeKit & UnsetSize();
13906 
13909  TextAttributeKit & UnsetFont();
13910 
13913  TextAttributeKit & UnsetTransform();
13914 
13917  TextAttributeKit & UnsetRenderer();
13918 
13921  TextAttributeKit & UnsetPreference();
13922 
13925  TextAttributeKit & UnsetPath();
13926 
13929  TextAttributeKit & UnsetSpacing();
13930 
13933  TextAttributeKit & UnsetBackground();
13934 
13937  TextAttributeKit & UnsetBackgroundMargins();
13938 
13941  TextAttributeKit & UnsetBackgroundStyle();
13942 
13945  TextAttributeKit & UnsetEverything();
13946 
13947 
13953  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13954 
13958  bool ShowBold(bool & out_state) const;
13959 
13963  bool ShowItalic(bool & out_state) const;
13964 
13968  bool ShowOverline(bool & out_state) const;
13969 
13973  bool ShowStrikethrough(bool & out_state) const;
13974 
13978  bool ShowUnderline(bool & out_state) const;
13979 
13983  bool ShowSlant(float & out_angle) const;
13984 
13988  bool ShowLineSpacing(float & out_multiplier) const;
13989 
13994  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13995 
14001  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
14002 
14009  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
14010 
14016  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
14017 
14022  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
14023 
14027  bool ShowFont(UTF8 & out_name) const;
14028 
14032  bool ShowTransform(Text::Transform & out_trans) const;
14033 
14037  bool ShowRenderer(Text::Renderer & out_rend) const;
14038 
14045  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
14046 
14050  bool ShowPath(Vector & out_path) const;
14051 
14055  bool ShowSpacing(float & out_multiplier) const;
14056 
14061  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
14062 
14067  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
14068 
14072  bool ShowBackgroundStyle(UTF8 & out_name) const;
14073 };
14074 
14080 class HPS_API TextAttributeControl : public Control
14081 {
14082 public:
14083 
14085  explicit TextAttributeControl(SegmentKey & in_seg);
14086 
14088  TextAttributeControl(TextAttributeControl const & in_that);
14089 
14094 
14098  TextAttributeControl & operator=(TextAttributeControl && in_that);
14099 
14102 
14103  virtual HPS::Type Type() const { return ObjectType(); }
14104 
14105  HPS::Type ObjectType() const {return HPS::Type::TextAttributeControl;};
14106 
14110  TextAttributeControl & operator=(TextAttributeControl const & in_that);
14111 
14118 
14123  TextAttributeControl & SetBold(bool in_state);
14124 
14129  TextAttributeControl & SetItalic(bool in_state);
14130 
14134  TextAttributeControl & SetOverline(bool in_state);
14135 
14139  TextAttributeControl & SetStrikethrough(bool in_state);
14140 
14144  TextAttributeControl & SetUnderline(bool in_state);
14145 
14151  TextAttributeControl & SetSlant(float in_angle);
14152 
14157  TextAttributeControl & SetLineSpacing(float in_multiplier);
14158 
14163  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
14164 
14169  TextAttributeControl & SetRotation(float in_angle);
14170 
14176  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
14177 
14183  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
14184 
14191  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
14192 
14199 
14209  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
14210 
14220  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
14221 
14226  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
14227 
14234  TextAttributeControl & SetFont(char const * in_name);
14235 
14239  TextAttributeControl & SetTransform(Text::Transform in_trans);
14240 
14244  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
14245 
14250  TextAttributeControl & SetPreference(Text::Preference in_pref);
14251 
14259  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
14260 
14265  TextAttributeControl & SetPath(Vector const & in_path);
14266 
14274  TextAttributeControl & SetSpacing(float in_multiplier);
14275 
14280  TextAttributeControl & SetBackground(bool in_state, char const * in_name);
14281 
14286  TextAttributeControl & SetBackground(char const * in_name);
14287 
14291  TextAttributeControl & SetBackground(bool in_state);
14292 
14297  TextAttributeControl & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
14298 
14304  TextAttributeControl & SetBackgroundMargins(FloatArray const & in_size, TextMarginUnitsArray const & in_units);
14305 
14312  TextAttributeControl & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
14313 
14318  TextAttributeControl & SetBackgroundStyle(char const * in_name);
14319 
14320 
14324  TextAttributeControl & UnsetAlignment();
14325 
14329  TextAttributeControl & UnsetBold();
14330 
14334  TextAttributeControl & UnsetItalic();
14335 
14339  TextAttributeControl & UnsetOverline();
14340 
14344  TextAttributeControl & UnsetStrikethrough();
14345 
14349  TextAttributeControl & UnsetUnderline();
14350 
14354  TextAttributeControl & UnsetSlant();
14355 
14359  TextAttributeControl & UnsetLineSpacing();
14360 
14364  TextAttributeControl & UnsetRotation();
14365 
14369  TextAttributeControl & UnsetExtraSpace();
14370 
14374  TextAttributeControl & UnsetGreeking();
14375 
14379  TextAttributeControl & UnsetSizeTolerance();
14380 
14384  TextAttributeControl & UnsetSize();
14385 
14389  TextAttributeControl & UnsetFont();
14390 
14394  TextAttributeControl & UnsetTransform();
14395 
14399  TextAttributeControl & UnsetRenderer();
14400 
14404  TextAttributeControl & UnsetPreference();
14405 
14409  TextAttributeControl & UnsetPath();
14410 
14414  TextAttributeControl & UnsetSpacing();
14415 
14419  TextAttributeControl & UnsetBackground();
14420 
14424  TextAttributeControl & UnsetBackgroundMargins();
14425 
14429  TextAttributeControl & UnsetBackgroundStyle();
14430 
14434  TextAttributeControl & UnsetEverything();
14435 
14436 
14442  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
14443 
14447  bool ShowBold(bool & out_state) const;
14448 
14452  bool ShowItalic(bool & out_state) const;
14453 
14457  bool ShowOverline(bool & out_state) const;
14458 
14462  bool ShowStrikethrough(bool & out_state) const;
14463 
14467  bool ShowUnderline(bool & out_state) const;
14468 
14472  bool ShowSlant(float & out_angle) const;
14473 
14477  bool ShowLineSpacing(float & out_multiplier) const;
14478 
14483  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
14484 
14490  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
14491 
14498  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
14499 
14505  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
14506 
14511  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
14512 
14516  bool ShowFont(UTF8 & out_name) const;
14517 
14521  bool ShowTransform(Text::Transform & out_trans) const;
14522 
14526  bool ShowRenderer(Text::Renderer & out_rend) const;
14527 
14534  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
14535 
14539  bool ShowPath(Vector & out_path) const;
14540 
14544  bool ShowSpacing(float & out_multiplier) const;
14545 
14550  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
14551 
14556  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
14557 
14561  bool ShowBackgroundStyle(UTF8 & out_name) const;
14562 
14563 private:
14566 };
14567 
14568 
14569 
14570 
14571 
14573 class HPS_API LineAttributeKit : public Kit
14574 {
14575 public:
14576 
14578  LineAttributeKit();
14579 
14582  LineAttributeKit(LineAttributeKit const & in_kit);
14583 
14587  LineAttributeKit(LineAttributeKit && in_that);
14588 
14592  LineAttributeKit & operator=(LineAttributeKit && in_that);
14593 
14595  virtual ~LineAttributeKit();
14596 
14597  HPS::Type ObjectType() const {return HPS::Type::LineAttributeKit;};
14598 
14602  static LineAttributeKit GetDefault();
14603 
14606  void Set(LineAttributeKit const & in_kit);
14607 
14610  void Show(LineAttributeKit & out_kit) const;
14611 
14615  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
14616 
14619  bool Empty() const;
14620 
14624  bool Equals(LineAttributeKit const & in_kit) const;
14625 
14629  bool operator==(LineAttributeKit const & in_kit) const;
14630 
14634  bool operator!=(LineAttributeKit const & in_kit) const;
14635 
14636 
14640  LineAttributeKit & SetPattern(char const * in_name);
14641 
14646  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
14647 
14652  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
14653 
14654 
14657  LineAttributeKit & UnsetPattern();
14658 
14661  LineAttributeKit & UnsetWeight();
14662 
14665  LineAttributeKit & UnsetEverything();
14666 
14667 
14672  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
14673 
14678  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
14679 };
14680 
14686 class HPS_API LineAttributeControl : public Control
14687 {
14688 public:
14689 
14691  explicit LineAttributeControl(SegmentKey & in_seg);
14692 
14694  LineAttributeControl(LineAttributeControl const & in_that);
14695 
14700 
14704  LineAttributeControl & operator=(LineAttributeControl && in_that);
14705 
14708 
14709  virtual HPS::Type Type() const { return ObjectType(); }
14710 
14711  HPS::Type ObjectType() const {return HPS::Type::LineAttributeControl;};
14712 
14716  LineAttributeControl & operator=(LineAttributeControl const & in_that);
14717 
14721  LineAttributeControl & SetPattern(char const * in_pattern);
14722 
14727  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
14728 
14733  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
14734 
14735 
14739  LineAttributeControl & UnsetPattern();
14740 
14744  LineAttributeControl & UnsetWeight();
14745 
14749  LineAttributeControl & UnsetEverything();
14750 
14751 
14756  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
14757 
14762  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
14763 
14764 private:
14767 };
14768 
14769 
14770 
14772 class HPS_API EdgeAttributeKit : public Kit
14773 {
14774 public:
14775 
14777  EdgeAttributeKit();
14778 
14781  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
14782 
14786  EdgeAttributeKit(EdgeAttributeKit && in_that);
14787 
14791  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
14792 
14794  virtual ~EdgeAttributeKit();
14795 
14796  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeKit;};
14797 
14801  static EdgeAttributeKit GetDefault();
14802 
14805  void Set(EdgeAttributeKit const & in_kit);
14806 
14809  void Show(EdgeAttributeKit & out_kit) const;
14810 
14814  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
14815 
14818  bool Empty() const;
14819 
14823  bool Equals(EdgeAttributeKit const & in_kit) const;
14824 
14828  bool operator==(EdgeAttributeKit const & in_kit) const;
14829 
14833  bool operator!=(EdgeAttributeKit const & in_kit) const;
14834 
14835 
14839  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
14840 
14845  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
14846 
14850  EdgeAttributeKit & SetHardAngle(float in_angle);
14851 
14852 
14855  EdgeAttributeKit & UnsetPattern();
14856 
14859  EdgeAttributeKit & UnsetWeight();
14860 
14863  EdgeAttributeKit & UnsetHardAngle();
14864 
14867  EdgeAttributeKit & UnsetEverything();
14868 
14869 
14873  bool ShowPattern(UTF8 & out_pattern_name) const;
14874 
14879  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14880 
14884  bool ShowHardAngle(float & out_angle) const;
14885 
14886 };
14887 
14893 class HPS_API EdgeAttributeControl : public Control
14894 {
14895 public:
14896 
14898  explicit EdgeAttributeControl(SegmentKey & in_seg);
14899 
14901  EdgeAttributeControl(EdgeAttributeControl const & in_that);
14902 
14907 
14911  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
14912 
14915 
14916  virtual HPS::Type Type() const { return ObjectType(); }
14917 
14918  HPS::Type ObjectType() const {return HPS::Type::EdgeAttributeControl;};
14919 
14923  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
14924 
14928  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
14929 
14934  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
14935 
14939  EdgeAttributeControl & SetHardAngle(float in_angle);
14940 
14941 
14945  EdgeAttributeControl & UnsetPattern();
14946 
14950  EdgeAttributeControl & UnsetWeight();
14951 
14955  EdgeAttributeControl & UnsetHardAngle();
14956 
14960  EdgeAttributeControl & UnsetEverything();
14961 
14962 
14966  bool ShowPattern(UTF8 & out_pattern_name) const;
14967 
14972  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
14973 
14977  bool ShowHardAngle(float & out_angle) const;
14978 
14979 private:
14982 };
14983 
14984 
14986 class HPS_API CurveAttributeKit : public Kit
14987 {
14988 public:
14989 
14992 
14995  CurveAttributeKit(CurveAttributeKit const & in_kit);
14996 
15001 
15005  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
15006 
15008  virtual ~CurveAttributeKit();
15009 
15010  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeKit;};
15011 
15015  static CurveAttributeKit GetDefault();
15016 
15019  void Set(CurveAttributeKit const & in_kit);
15020 
15023  void Show(CurveAttributeKit & out_kit) const;
15024 
15028  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
15029 
15032  bool Empty() const;
15033 
15037  bool Equals(CurveAttributeKit const & in_kit) const;
15038 
15042  bool operator==(CurveAttributeKit const & in_kit) const;
15043 
15047  bool operator!=(CurveAttributeKit const & in_kit) const;
15048 
15049  //Set
15050  CurveAttributeKit & SetBudget(size_t in_budget);
15051 
15058  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
15059 
15066  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
15067 
15068 
15075  CurveAttributeKit & SetViewDependent(bool in_state);
15076 
15080  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
15081 
15086  CurveAttributeKit & SetMaximumAngle(float in_degrees);
15087 
15092  CurveAttributeKit & SetMaximumLength(float in_length);
15093 
15094 
15097  CurveAttributeKit & UnsetBudget();
15098 
15101  CurveAttributeKit & UnsetContinuedBudget();
15102 
15105  CurveAttributeKit & UnsetViewDependent();
15106 
15109  CurveAttributeKit & UnsetMaximumDeviation();
15110 
15113  CurveAttributeKit & UnsetMaximumAngle();
15114 
15117  CurveAttributeKit & UnsetMaximumLength();
15118 
15121  CurveAttributeKit & UnsetEverything();
15122 
15123 
15127  bool ShowBudget(size_t & out_budget) const;
15128 
15133  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
15134 
15138  bool ShowViewDependent(bool & out_state) const;
15139 
15144  bool ShowMaximumDeviation(float & out_deviation) const;
15145 
15150  bool ShowMaximumAngle(float & out_degrees) const;
15151 
15156  bool ShowMaximumLength(float & out_length) const;
15157 };
15158 
15159 
15163 class HPS_API CurveAttributeControl : public Control
15164 {
15165 public:
15166 
15168  explicit CurveAttributeControl(SegmentKey & in_seg);
15169 
15172 
15177 
15181  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
15182 
15185 
15186  virtual HPS::Type Type() const { return ObjectType(); }
15187 
15188  HPS::Type ObjectType() const {return HPS::Type::CurveAttributeControl;};
15189 
15193  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
15194 
15198  CurveAttributeControl & SetBudget(size_t in_budget);
15199 
15206  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
15207 
15214  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
15215 
15222  CurveAttributeControl & SetViewDependent(bool in_state);
15223 
15227  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
15228 
15233  CurveAttributeControl & SetMaximumAngle(float in_degrees);
15234 
15239  CurveAttributeControl & SetMaximumLength(float in_length);
15240 
15241 
15245  CurveAttributeControl & UnsetBudget();
15246 
15250  CurveAttributeControl & UnsetContinuedBudget();
15251 
15255  CurveAttributeControl & UnsetViewDependent();
15256 
15260  CurveAttributeControl & UnsetMaximumDeviation();
15261 
15265  CurveAttributeControl & UnsetMaximumAngle();
15266 
15270  CurveAttributeControl & UnsetMaximumLength();
15271 
15275  CurveAttributeControl & UnsetEverything();
15276 
15277 
15281  bool ShowBudget(size_t & out_budget) const;
15282 
15287  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
15288 
15292  bool ShowViewDependent(bool & out_state) const;
15293 
15298  bool ShowMaximumDeviation(float & out_deviation) const;
15299 
15304  bool ShowMaximumAngle(float & out_degrees) const;
15305 
15310  bool ShowMaximumLength(float & out_length) const;
15311 
15312 private:
15315 };
15316 
15317 
15318 
15319 
15321 class HPS_API MatrixKit : public Kit
15322 {
15323 public:
15324 
15326  MatrixKit();
15327 
15330  MatrixKit(MatrixKit const & in_kit);
15331 
15335  MatrixKit(MatrixKit && in_that);
15336 
15340  MatrixKit & operator=(MatrixKit && in_that);
15341 
15345  MatrixKit(FloatArray const & in_matrix_source);
15346 
15350  MatrixKit(float const in_matrix_source []);
15351 
15354  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
15355 
15357  virtual ~MatrixKit();
15358 
15359  HPS::Type ObjectType() const {return HPS::Type::MatrixKit;};
15360 
15363  static MatrixKit GetDefault();
15364 
15367  void Set(MatrixKit const & in_kit);
15368 
15371  void Show(MatrixKit & out_kit) const;
15372 
15376  MatrixKit & operator=(MatrixKit const & in_kit);
15377 
15380  bool Empty() const;
15381 
15385  bool Equals(MatrixKit const & in_kit) const;
15386 
15390  bool operator==(MatrixKit const & in_kit) const;
15391 
15395  bool operator!=(MatrixKit const & in_kit) const;
15396 
15402  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
15403 
15408  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
15409 
15413  MatrixKit & SetElements(FloatArray const & in_values);
15414 
15419  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
15420 
15421 
15424  MatrixKit & UnsetEverything();
15425 
15426 
15432  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
15433 
15438  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
15439 
15443  bool ShowElements(FloatArray & out_matrix) const;
15444 
15445 #ifndef HPS_GULP_CLANG
15446 
15449  bool ShowElements(float out_matrix[]) const;
15450 #endif
15451 
15455  bool ShowDeterminant(float & out_determinant) const;
15456 
15460  bool ShowInverse(MatrixKit & out_matrix) const;
15461 
15466  bool ShowAdjoint(MatrixKit & out_matrix) const;
15467 
15468 
15474  MatrixKit & Rotate(float in_x, float in_y, float in_z);
15475 
15480  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
15481 
15487  MatrixKit & Translate(float in_x, float in_y, float in_z);
15488 
15492  MatrixKit & Translate(Vector const & in_translation);
15493 
15499  MatrixKit & Scale(float in_x, float in_y, float in_z);
15500 
15504  MatrixKit & Concatenate(MatrixKit const & in_kit);
15505 
15508  MatrixKit & Normalize();
15509 
15512  MatrixKit & Invert();
15513 
15517  MatrixKit & Adjoint();
15518 
15519 
15523  MatrixKit Multiply(MatrixKit const & in_right) const;
15524 
15528  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
15529 
15533  MatrixKit Multiply(float in_scalar) const;
15534 
15538  MatrixKit const & MultiplyAndAssign(float in_scalar);
15539 
15543  MatrixKit operator*(MatrixKit const & in_right) const;
15544 
15548  MatrixKit const & operator*=(MatrixKit const & in_right);
15549 
15553  MatrixKit operator*(float in_scalar) const;
15554 
15558  MatrixKit const & operator*=(float in_scalar);
15559 
15560 
15564  Point Transform(Point const & in_source) const;
15565 
15569  PointArray Transform(PointArray const & in_source) const;
15570 
15575  PointArray Transform(size_t in_count, Point const in_source []) const;
15576 
15580  Vector Transform(Vector const & in_source) const;
15581 
15585  VectorArray Transform(VectorArray const & in_source) const;
15586 
15591  VectorArray Transform(size_t in_count, Vector const in_source []) const;
15592 
15596  Plane Transform(Plane const & in_source) const;
15597 
15601  PlaneArray Transform(PlaneArray const & in_source) const;
15602 
15607  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
15608 
15612  SimpleCuboid Transform(SimpleCuboid const & in_source) const;
15613 
15617  SimpleSphere Transform(SimpleSphere const & in_source) const;
15618 };
15619 
15623 class HPS_API ModellingMatrixControl : public Control
15624 {
15625 public:
15626 
15628  explicit ModellingMatrixControl(SegmentKey const & in_seg);
15629 
15631  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
15632 
15635 
15640 
15644  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
15645 
15648 
15649  virtual HPS::Type Type() const { return ObjectType(); }
15650 
15651  HPS::Type ObjectType() const {return HPS::Type::ModellingMatrixControl;};
15652 
15656  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
15657 
15663  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
15664 
15669  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
15670 
15674  ModellingMatrixControl & SetElements(FloatArray const & in_values);
15675 
15680  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
15681 
15682 
15685  ModellingMatrixControl & UnsetEverything();
15686 
15687 
15693  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
15694 
15699  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
15700 
15704  bool ShowElements(FloatArray & out_matrix) const;
15705 
15709  bool ShowDeterminant(float & out_determinant) const;
15710 
15714  bool ShowInverse(MatrixKit & out_matrix) const;
15715 
15720  bool ShowAdjoint(MatrixKit & out_matrix) const;
15721 
15727  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
15728 
15733  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
15734 
15740  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
15741 
15745  ModellingMatrixControl & Translate(Vector const & in_translation);
15746 
15752  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
15753 
15757  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
15758 
15761  ModellingMatrixControl & Normalize();
15762 
15765  ModellingMatrixControl & Invert();
15766 
15770  ModellingMatrixControl & Adjoint();
15771 
15772 private:
15775 };
15776 
15779 class HPS_API TextureMatrixControl : public Control
15780 {
15781 public:
15782 
15784  explicit TextureMatrixControl(SegmentKey & in_seg);
15785 
15787  TextureMatrixControl(const TextureMatrixControl & in_that);
15788 
15793 
15797  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
15798 
15801 
15802  virtual HPS::Type Type() const { return ObjectType(); }
15803 
15804  HPS::Type ObjectType() const {return HPS::Type::TextureMatrixControl;};
15805 
15809  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
15810 
15816  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
15817 
15822  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
15823 
15827  TextureMatrixControl & SetElements(FloatArray const & in_values);
15828 
15833  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
15834 
15835 
15838  TextureMatrixControl & UnsetEverything();
15839 
15840 
15846  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
15847 
15852  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
15853 
15857  bool ShowElements(FloatArray & out_matrix) const;
15858 
15862  bool ShowDeterminant(float & out_determinant) const;
15863 
15867  bool ShowInverse(MatrixKit & out_matrix) const;
15868 
15873  bool ShowAdjoint(MatrixKit & out_matrix) const;
15874 
15880  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
15881 
15886  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
15887 
15893  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
15894 
15900  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
15901 
15905  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
15906 
15909  TextureMatrixControl & Normalize();
15910 
15913  TextureMatrixControl & Invert();
15914 
15918  TextureMatrixControl & Adjoint();
15919 
15920 private:
15923 };
15924 
15925 
15928 class HPS_API MaterialMappingKit : public Kit
15929 {
15930 public:
15931 
15934 
15937  MaterialMappingKit(MaterialMappingKit const & in_kit);
15938 
15943 
15947  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
15948 
15950  ~MaterialMappingKit();
15951 
15952  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingKit;};
15953 
15957  static MaterialMappingKit GetDefault();
15958 
15961  void Set(MaterialMappingKit const & in_kit);
15962 
15965  void Show(MaterialMappingKit & out_kit) const;
15966 
15970  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
15971 
15974  bool Empty() const;
15975 
15979  bool Equals(MaterialMappingKit const & in_kit) const;
15980 
15984  bool operator==(MaterialMappingKit const & in_kit) const;
15985 
15989  bool operator!=(MaterialMappingKit const & in_kit) const;
15990 
15991  //Set
15992 
15996  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15997 
16003  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
16004 
16005 
16009  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
16010 
16016  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
16017 
16023  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16024 
16029  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
16030 
16037  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16038 
16047  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);
16048 
16052  MaterialMappingKit & SetBackFaceGloss(float in_value);
16053 
16057  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
16058 
16063  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
16064 
16070  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16071 
16076  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
16077 
16084  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16085 
16094  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);
16095 
16099  MaterialMappingKit & SetFrontFaceGloss(float in_value);
16100 
16104  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
16105 
16110  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
16111 
16112 
16116  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
16117 
16123  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
16124 
16130  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16131 
16136  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
16137 
16144  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16145 
16154  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);
16155 
16159  MaterialMappingKit & SetCutFaceGloss(float in_value);
16160 
16164  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
16165 
16170  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
16171 
16176  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
16177 
16183  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16184 
16191  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16192 
16201  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);
16202 
16206  MaterialMappingKit & SetEdgeGloss(float in_value);
16207 
16211  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
16212 
16217  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
16218 
16223  MaterialMappingKit & SetFaceAlpha(float in_alpha);
16224 
16230  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16231 
16238  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16239 
16248  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);
16249 
16253  MaterialMappingKit & SetFaceGloss(float in_value);
16254 
16258  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
16259 
16264  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
16265 
16269  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
16270 
16271 
16272 
16273 
16274 
16278  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
16279 
16285  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
16286 
16287 
16291  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
16292 
16298  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
16299 
16300 
16304  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
16305 
16311  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
16312 
16313 
16317  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
16318 
16324  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
16325 
16330  MaterialMappingKit & SetVertexAlpha(float in_alpha);
16331 
16337  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16338 
16345  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16346 
16355  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);
16356 
16360  MaterialMappingKit & SetVertexGloss(float in_value);
16361 
16365  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
16366 
16371  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
16372 
16376  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
16377 
16378 
16382  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
16383 
16389  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
16390 
16391 
16395  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
16396 
16402  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
16403 
16404  //Aggregate Sets
16405 
16409  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
16410 
16415  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
16416 
16417 
16421  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
16422 
16428  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
16429 
16430 
16431  //Unset
16432 
16435  MaterialMappingKit & UnsetAmbientLightUpColor();
16436 
16437 
16440  MaterialMappingKit & UnsetAmbientLightDownColor();
16441 
16442 
16445  MaterialMappingKit & UnsetBackFaceMaterial();
16446 
16449  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
16450 
16453  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
16454 
16457  MaterialMappingKit & UnsetFrontFaceMaterial();
16458 
16461  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
16462 
16465  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
16466 
16467 
16468 
16471  MaterialMappingKit & UnsetCutEdgeColor();
16472 
16473 
16476  MaterialMappingKit & UnsetCutFaceMaterial();
16477 
16480  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
16481 
16484  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
16485 
16486 
16489  MaterialMappingKit & UnsetEdgeMaterial();
16490 
16493  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
16494 
16497  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
16498 
16499 
16502  MaterialMappingKit & UnsetFaceMaterial();
16503 
16506  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
16507 
16510  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
16511 
16512 
16515  MaterialMappingKit & UnsetLightColor();
16516 
16517 
16520  MaterialMappingKit & UnsetLineColor();
16521 
16522 
16525  MaterialMappingKit & UnsetMarkerColor();
16526 
16527 
16530  MaterialMappingKit & UnsetTextColor();
16531 
16532 
16535  MaterialMappingKit & UnsetVertexMaterial();
16536 
16539  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
16540 
16543  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
16544 
16545 
16548  MaterialMappingKit & UnsetWindowColor();
16549 
16550 
16553  MaterialMappingKit & UnsetWindowContrastColor();
16554 
16555 
16556  //Aggregate Unsets
16557 
16560  MaterialMappingKit & UnsetCutGeometryColor();
16561 
16564  MaterialMappingKit & UnsetAmbientLightColor();
16565 
16568  MaterialMappingKit & UnsetEverything();
16569 
16570 
16571  //Show
16572 
16578  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16579 
16585  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16586 
16587 
16596  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16597 
16607  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;
16608 
16614  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16615 
16616 
16625  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16626 
16636  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;
16637 
16643  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16644 
16645 
16646 
16652  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16653 
16654 
16662  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16663 
16672  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;
16673 
16679  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16680 
16681 
16689  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16690 
16699  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;
16700 
16706  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16707 
16708 
16717  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16718 
16728  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;
16729 
16735  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16736 
16737 
16743  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16744 
16745 
16751  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16752 
16753 
16759  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16760 
16761 
16767  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16768 
16769 
16777  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16778 
16787  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;
16788 
16794  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16795 
16796 
16802  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16803 
16804 
16810  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16811 };
16812 
16813 
16819 class HPS_API MaterialMappingControl : public Control
16820 {
16821 public:
16822 
16824  explicit MaterialMappingControl(SegmentKey & in_seg);
16825 
16828 
16833 
16837  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
16838 
16841 
16842  virtual HPS::Type Type() const { return ObjectType(); }
16843 
16844  HPS::Type ObjectType() const {return HPS::Type::MaterialMappingControl;};
16845 
16849  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
16850 
16851  //Set
16852 
16856  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
16857 
16863  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
16864 
16865 
16869  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
16870 
16876  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
16877 
16882  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
16883 
16889  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16890 
16897  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16898 
16907  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);
16908 
16912  MaterialMappingControl & SetBackFaceGloss(float in_value);
16913 
16917  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
16918 
16923  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
16924 
16925 
16930  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
16931 
16937  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16938 
16945  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
16946 
16955  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);
16956 
16960  MaterialMappingControl & SetFrontFaceGloss(float in_value);
16961 
16965  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
16966 
16971  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
16972 
16976  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
16977 
16983  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
16984 
16989  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
16990 
16996  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
16997 
17004  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17005 
17014  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);
17015 
17019  MaterialMappingControl & SetCutFaceGloss(float in_value);
17020 
17024  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
17025 
17030  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
17031 
17036  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
17037 
17043  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17044 
17051  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17052 
17061  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);
17062 
17066  MaterialMappingControl & SetEdgeGloss(float in_value);
17067 
17071  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
17072 
17077  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
17078 
17084  MaterialMappingControl & SetFaceAlpha(float in_alpha);
17085 
17092  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17093 
17100  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17101 
17110  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);
17111 
17115  MaterialMappingControl & SetFaceGloss(float in_value);
17116 
17120  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
17121 
17126  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
17127 
17131  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
17132 
17133 
17137  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
17138 
17144  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
17145 
17146 
17150  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
17151 
17157  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
17158 
17159 
17163  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
17164 
17170  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
17171 
17172 
17176  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
17177 
17183  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
17184 
17185 
17190  MaterialMappingControl & SetVertexAlpha(float in_alpha);
17191 
17192 
17198  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
17199 
17206  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
17207 
17216  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);
17217 
17221  MaterialMappingControl & SetVertexGloss(float in_value);
17222 
17226  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
17227 
17232  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
17233 
17237  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
17238 
17239 
17243  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
17244 
17250  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
17251 
17252 
17256  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
17257 
17263  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
17264 
17265  //Aggregate Sets
17266 
17270  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
17271 
17276  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
17277 
17278 
17282  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
17283 
17289  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
17290 
17291 
17292  //Unset
17293 
17297  MaterialMappingControl & UnsetAmbientLightUpColor();
17298 
17299 
17303  MaterialMappingControl & UnsetAmbientLightDownColor();
17304 
17305 
17309  MaterialMappingControl & UnsetFrontFaceMaterial();
17310 
17314  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
17315 
17319  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
17320 
17321 
17325  MaterialMappingControl & UnsetBackFaceMaterial();
17326 
17330  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
17331 
17335  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
17336 
17337 
17341  MaterialMappingControl & UnsetCutEdgeColor();
17342 
17343 
17347  MaterialMappingControl & UnsetCutFaceMaterial();
17348 
17352  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
17353 
17357  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
17358 
17359 
17363  MaterialMappingControl & UnsetEdgeMaterial();
17364 
17368  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
17369 
17373  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
17374 
17375 
17379  MaterialMappingControl & UnsetFaceMaterial();
17380 
17384  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
17385 
17389  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
17390 
17391 
17395  MaterialMappingControl & UnsetLightColor();
17396 
17397 
17401  MaterialMappingControl & UnsetLineColor();
17402 
17403 
17407  MaterialMappingControl & UnsetMarkerColor();
17408 
17409 
17413  MaterialMappingControl & UnsetTextColor();
17414 
17415 
17419  MaterialMappingControl & UnsetVertexMaterial();
17420 
17424  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
17425 
17429  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
17430 
17431 
17435  MaterialMappingControl & UnsetWindowColor();
17436 
17437 
17441  MaterialMappingControl & UnsetWindowContrastColor();
17442 
17443 
17444  //Aggregate Unsets
17445 
17449  MaterialMappingControl & UnsetCutGeometryColor();
17450 
17454  MaterialMappingControl & UnsetAmbientLightColor();
17455 
17459  MaterialMappingControl & UnsetEverything();
17460 
17461 
17462  //Show
17463 
17469  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17470 
17471 
17477  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17478 
17479 
17488  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17489 
17499  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;
17500 
17506  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17507 
17508 
17517  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17518 
17528  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;
17529 
17535  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17536 
17537 
17543  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17544 
17545 
17553  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17554 
17563  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;
17564 
17570  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17571 
17572 
17580  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17581 
17590  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;
17591 
17597  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17598 
17599 
17608  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17609 
17619  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;
17620 
17626  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17627 
17628 
17634  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17635 
17636 
17642  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17643 
17644 
17650  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17651 
17652 
17658  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17659 
17660 
17668  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
17669 
17678  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;
17679 
17685  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
17686 
17687 
17693  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17694 
17695 
17701  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
17702 
17703 private:
17705 };
17706 
17707 
17710 class HPS_API PortfolioControl : public Control
17711 {
17712 public:
17714  explicit PortfolioControl(SegmentKey & in_seg);
17715 
17717  PortfolioControl(PortfolioControl const & in_that);
17718 
17722  PortfolioControl(PortfolioControl && in_that);
17723 
17727  PortfolioControl & operator=(PortfolioControl && in_that);
17728 
17730  ~PortfolioControl();
17731 
17732  virtual HPS::Type Type() const { return ObjectType(); }
17733 
17734  HPS::Type ObjectType() const { return HPS::Type::PortfolioControl; };
17735 
17739  PortfolioControl & operator=(PortfolioControl const & in_that);
17740 
17742  size_t GetCount() const;
17743 
17744 
17749  PortfolioControl & Push(PortfolioKey const & in_portfolio);
17750 
17753  bool Pop();
17754 
17758  bool Pop(PortfolioKey & out_portfolio);
17759 
17760 
17764  PortfolioControl & Set(PortfolioKey const & in_portfolio);
17765 
17769  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
17770 
17775  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
17776 
17777 
17780  PortfolioControl & UnsetTop();
17781 
17784  PortfolioControl & UnsetEverything();
17785 
17786 
17790  bool ShowTop(PortfolioKey & out_portfolio) const;
17791 
17795  bool Show(PortfolioKeyArray & out_portfolios) const;
17796 
17797 private:
17798  PortfolioControl();
17799 };
17800 
17801 
17802 
17805 class HPS_API StyleControl : public Control
17806 {
17807 public:
17809  explicit StyleControl(SegmentKey & in_seg);
17810 
17812  StyleControl(StyleControl const & in_that);
17813 
17817  StyleControl(StyleControl && in_that);
17818 
17822  StyleControl & operator=(StyleControl && in_that);
17823 
17825  ~StyleControl();
17826 
17827  virtual HPS::Type Type() const { return ObjectType(); }
17828 
17829  HPS::Type ObjectType() const { return HPS::Type::StyleControl; };
17830 
17834  StyleControl & operator=(StyleControl const & in_that);
17835 
17837  size_t GetCount() const;
17838 
17840  StyleKey PushNamed(char const * in_style_name);
17841 
17847  StyleKey PushNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
17848 
17855  StyleKey AppendNamed(char const * in_style_name, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
17856 
17861  StyleKey PushSegment(SegmentKey const & in_style_source);
17862 
17868  StyleKey PushSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
17869 
17876  StyleKey AppendSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional, Style::AppendMode in_mode = Style::AppendMode::Or);
17877 
17878 
17879 
17882  bool Pop();
17883 
17890  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional);
17891 
17895  void Flush(SegmentKey const & in_style_source);
17896 
17903  void Flush(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
17904 
17908  void Flush(char const * in_style_name);
17909 
17916  void Flush(char const * in_style_name, ConditionalExpression const & in_conditional);
17917 
17918 
17921  StyleKey SetNamed(char const * in_style_name);
17922 
17926  StyleKey SetNamed(char const * in_style_name, ConditionalExpression const & in_conditional);
17927 
17928 
17931  StyleKey SetSegment(SegmentKey const & in_style_source);
17932 
17936  StyleKey SetSegment(SegmentKey const & in_style_source, ConditionalExpression const & in_conditional);
17937 
17938 
17944  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionalExpressionArray const & in_conditions);
17945 
17950  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
17951 
17958  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[]);
17959 
17960 
17961 
17963  void UnsetTop();
17964 
17966  void UnsetAllSegment();
17967 
17969  void UnsetAllNamed();
17970 
17972  void UnsetEverything();
17973 
17974 
17981  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, ConditionalExpression & out_conditional) const;
17982 
17986  bool ShowTop(StyleKey & out_style) const;
17987 
17994  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionalExpressionArray & out_conditions) const;
17995 
17999  bool Show(StyleKeyArray & out_styles) const;
18000 
18005  bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionalExpressionArray & out_conditions) const;
18006 
18010  bool ShowAllSegment(StyleKeyArray & out_styles) const;
18011 
18016  bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionalExpressionArray & out_conditions) const;
18017 
18021  bool ShowAllNamed(StyleKeyArray & out_styles) const;
18022 
18023 private:
18024  StyleControl();
18025 };
18026 
18027 
18030 class HPS_API ConditionControl : public Control
18031 {
18032 public:
18034  explicit ConditionControl(SegmentKey & in_seg);
18035 
18037  ConditionControl(ConditionControl const & in_that);
18038 
18042  ConditionControl(ConditionControl && in_that);
18043 
18047  ConditionControl & operator=(ConditionControl && in_that);
18048 
18050  ~ConditionControl();
18051 
18052  virtual HPS::Type Type() const { return ObjectType(); }
18053 
18054  HPS::Type ObjectType() const { return HPS::Type::ConditionControl; };
18055 
18059  ConditionControl & operator=(ConditionControl const & in_that);
18060 
18063  size_t GetCount() const;
18064 
18068  ConditionControl & AddCondition(char const * in_condition);
18069 
18070 
18074  ConditionControl & SetCondition(char const * in_condition);
18075 
18079  ConditionControl & SetConditions(UTF8Array const & in_conditions);
18080 
18085  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
18086 
18087 
18091  ConditionControl & UnsetCondition(char const * in_condition);
18092 
18095  ConditionControl & UnsetEverything();
18096 
18097 
18101  bool ShowCondition(char const * in_condition) const;
18102 
18106  bool ShowConditions(UTF8Array & out_conditions) const;
18107 
18108 private:
18110  ConditionControl();
18111 };
18112 
18113 
18116 class HPS_API MaterialKit : public Kit
18117 {
18118 public:
18119 
18121  MaterialKit();
18122 
18125  MaterialKit(MaterialKit const & in_kit);
18126 
18130  MaterialKit(MaterialKit && in_that);
18131 
18135  MaterialKit & operator=(MaterialKit && in_that);
18136 
18138  ~MaterialKit();
18139 
18140  HPS::Type ObjectType() const {return HPS::Type::MaterialKit;};
18141 
18144  void Set(MaterialKit const & in_kit);
18145 
18148  void Show(MaterialKit & out_kit) const;
18149 
18153  MaterialKit & operator=(MaterialKit const & in_kit);
18154 
18157  bool Empty() const;
18158 
18162  bool Equals(MaterialKit const & in_kit) const;
18163 
18167  bool operator==(MaterialKit const & in_kit) const;
18168 
18172  bool operator!=(MaterialKit const & in_kit) const;
18173 
18174 
18175  //Set
18176 
18180  MaterialKit & SetDiffuse(RGBColor const & in_color);
18181 
18185  MaterialKit & SetDiffuse(RGBAColor const & in_color);
18186 
18190  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
18191 
18195  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
18196 
18201  MaterialKit & SetDiffuseAlpha(float in_alpha);
18202 
18209  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
18210 
18218  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
18219 
18224  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
18225 
18231  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
18232 
18239  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
18240 
18248  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
18249 
18250 
18254  MaterialKit & SetShader(char const * in_shader_name);
18255 
18256 
18257 
18261  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
18262 
18266  MaterialKit & SetSpecular(char const * in_texture_name);
18267 
18272  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
18273 
18274 
18275 
18279  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
18280 
18284  MaterialKit & SetMirror(char const * in_texture_name);
18285 
18290  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
18291 
18292 
18293 
18297  MaterialKit & SetTransmission(char const * in_texture_name);
18298 
18303  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
18304 
18305 
18306 
18310  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
18311 
18315  MaterialKit & SetEmission(char const * in_texture_name);
18316 
18321  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
18322 
18323 
18324 
18328  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
18329 
18334  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
18335 
18339  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
18340 
18345  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
18346 
18349  MaterialKit & SetEnvironmentTexture();
18350 
18351 
18355  MaterialKit & SetBump(char const * in_texture_name);
18356 
18357 
18358 
18365  MaterialKit & SetGloss(float in_gloss);
18366 
18369  MaterialKit & UnsetDiffuseColorRGB();
18370 
18373  MaterialKit & UnsetDiffuseColor();
18374 
18377  MaterialKit & UnsetDiffuseAlpha();
18378 
18381  MaterialKit & UnsetDiffuseTexture();
18382 
18386  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
18387 
18390  MaterialKit & UnsetShader();
18391 
18394  MaterialKit & UnsetSpecular();
18395 
18398  MaterialKit & UnsetMirror();
18399 
18402  MaterialKit & UnsetTransmission();
18403 
18406  MaterialKit & UnsetEmission();
18407 
18410  MaterialKit & UnsetEnvironment();
18411 
18414  MaterialKit & UnsetBump();
18415 
18418  MaterialKit & UnsetGloss();
18419 
18422  MaterialKit & UnsetEverything();
18423 
18424 
18427  bool ShowDiffuse() const;
18428 
18432  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
18433 
18437  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
18438 
18442  bool ShowDiffuseAlpha(float & out_alpha) const;
18443 
18450  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18451 
18459  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18460 
18467  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
18468 
18472  bool ShowShader(UTF8 & out_shader_name) const;
18473 
18482  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18483 
18492  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18493 
18494 
18495 
18504  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18505 
18506 
18515  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18516 
18517 
18526  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
18527 
18528 
18532  bool ShowBump(UTF8 & out_texture_name) const;
18533 
18538  bool ShowGloss(float & out_gloss) const;
18539 };
18540 
18541 
18543 class HPS_API NURBSSurfaceAttributeKit : public Kit
18544 {
18545 public:
18546 
18549 
18553 
18558 
18562  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
18563 
18565  virtual ~NURBSSurfaceAttributeKit();
18566 
18567  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeKit;};
18568 
18572  static NURBSSurfaceAttributeKit GetDefault();
18573 
18576  void Set(NURBSSurfaceAttributeKit const & in_kit);
18577 
18580  void Show(NURBSSurfaceAttributeKit & out_kit) const;
18581 
18585  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
18586 
18589  bool Empty() const;
18590 
18594  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
18595 
18599  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
18600 
18604  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
18605 
18606 
18610  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
18611 
18616  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
18617 
18621  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
18622 
18626  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
18627 
18631  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
18632 
18637  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
18638 
18639 
18642  NURBSSurfaceAttributeKit & UnsetBudget();
18643 
18646  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
18647 
18650  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
18651 
18654  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
18655 
18658  NURBSSurfaceAttributeKit & UnsetTrimBudget();
18659 
18662  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
18663 
18666  NURBSSurfaceAttributeKit & UnsetEverything();
18667 
18671  bool ShowBudget(size_t & out_budget) const;
18672 
18676  bool ShowMaximumDeviation(float & out_deviation) const;
18677 
18681  bool ShowMaximumAngle(float & out_degrees) const;
18682 
18686  bool ShowMaximumWidth(float & out_width) const;
18687 
18691  bool ShowTrimBudget(size_t & out_budget) const;
18692 
18696  bool ShowMaximumTrimDeviation(float & out_deviation) const;
18697 };
18698 
18705 {
18706 public:
18707 
18709  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
18710 
18713 
18718 
18723 
18726 
18727  virtual HPS::Type Type() const { return ObjectType(); }
18728 
18729  HPS::Type ObjectType() const {return HPS::Type::NURBSSurfaceAttributeControl;};
18730 
18734  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
18735 
18739  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
18740 
18745  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
18746 
18750  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
18751 
18755  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
18756 
18760  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
18761 
18766  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
18767 
18768 
18772  NURBSSurfaceAttributeControl & UnsetBudget();
18773 
18777  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
18778 
18782  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
18783 
18787  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
18788 
18792  NURBSSurfaceAttributeControl & UnsetTrimBudget();
18793 
18797  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
18798 
18802  NURBSSurfaceAttributeControl & UnsetEverything();
18803 
18804 
18808  bool ShowBudget(size_t & out_budget) const;
18809 
18813  bool ShowMaximumDeviation(float & out_deviation) const;
18814 
18818  bool ShowMaximumAngle(float & out_degrees) const;
18819 
18823  bool ShowMaximumWidth(float & out_width) const;
18824 
18828  bool ShowTrimBudget(size_t & out_budget) const;
18829 
18833  bool ShowMaximumTrimDeviation(float & out_deviation) const;
18834 
18835 private:
18838 };
18839 
18840 
18841 
18843 class HPS_API PerformanceKit : public Kit
18844 {
18845 public:
18846 
18848  PerformanceKit();
18849 
18852  PerformanceKit(PerformanceKit const & in_kit);
18853 
18857  PerformanceKit(PerformanceKit && in_that);
18858 
18862  PerformanceKit & operator=(PerformanceKit && in_that);
18863 
18865  virtual ~PerformanceKit();
18866 
18867  HPS::Type ObjectType() const {return HPS::Type::PerformanceKit;};
18868 
18872  static PerformanceKit GetDefault();
18873 
18876  void Set(PerformanceKit const & in_kit);
18877 
18880  void Show(PerformanceKit & out_kit) const;
18881 
18885  PerformanceKit & operator=(PerformanceKit const & in_kit);
18886 
18889  bool Empty() const;
18890 
18894  bool Equals(PerformanceKit const & in_kit) const;
18895 
18899  bool operator==(PerformanceKit const & in_kit) const;
18900 
18904  bool operator!=(PerformanceKit const & in_kit) const;
18905 
18906 
18911 
18916  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
18917 
18918 
18921  PerformanceKit & UnsetDisplayLists();
18922 
18925  PerformanceKit & UnsetStaticModel();
18926 
18929  PerformanceKit & UnsetEverything();
18930 
18934  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
18935 
18939  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
18940 };
18941 
18942 
18948 class HPS_API PerformanceControl : public Control
18949 {
18950 public:
18951 
18953  explicit PerformanceControl(SegmentKey & in_seg);
18954 
18956  PerformanceControl(PerformanceControl const & in_that);
18957 
18962 
18966  PerformanceControl & operator=(PerformanceControl && in_that);
18967 
18969  ~PerformanceControl();
18970 
18971  virtual HPS::Type Type() const { return ObjectType(); }
18972 
18973  HPS::Type ObjectType() const {return HPS::Type::PerformanceControl;};
18974 
18978  PerformanceControl & operator=(PerformanceControl const & in_that);
18979 
18984 
18989  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
18990 
18991 
18995  PerformanceControl & UnsetDisplayLists();
18996 
19000  PerformanceControl & UnsetStaticModel();
19001 
19005  PerformanceControl & UnsetEverything();
19006 
19007 
19011  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
19012 
19016  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
19017 
19018 private:
19021 };
19022 
19023 
19024 
19026 class HPS_API HiddenLineAttributeKit : public Kit
19027 {
19028 public:
19029 
19032 
19036 
19041 
19045  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
19046 
19048  virtual ~HiddenLineAttributeKit();
19049 
19050  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeKit;};
19051 
19055  static HiddenLineAttributeKit GetDefault();
19056 
19059  void Set(HiddenLineAttributeKit const & in_kit);
19060 
19063  void Show(HiddenLineAttributeKit & out_kit) const;
19064 
19068  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
19069 
19072  bool Empty() const;
19073 
19077  bool Equals(HiddenLineAttributeKit const & in_kit) const;
19078 
19082  bool operator==(HiddenLineAttributeKit const & in_kit) const;
19083 
19087  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
19088 
19089 
19093  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
19094 
19100  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
19101 
19111  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
19112 
19116  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
19117 
19121  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
19122 
19126  HiddenLineAttributeKit & SetRenderText(bool in_state);
19127 
19132  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
19133 
19139  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
19140 
19144  HiddenLineAttributeKit & SetVisibility(bool in_state);
19145 
19150  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
19151 
19157  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
19158 
19159 
19162  HiddenLineAttributeKit & UnsetColor();
19163 
19166  HiddenLineAttributeKit & UnsetDimFactor();
19167 
19170  HiddenLineAttributeKit & UnsetFaceDisplacement();
19171 
19174  HiddenLineAttributeKit & UnsetLinePattern();
19175 
19178  HiddenLineAttributeKit & UnsetRenderFaces();
19179 
19182  HiddenLineAttributeKit & UnsetRenderText();
19183 
19186  HiddenLineAttributeKit & UnsetAlgorithm();
19187 
19190  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
19191 
19194  HiddenLineAttributeKit & UnsetVisibility();
19195 
19198  HiddenLineAttributeKit & UnsetWeight();
19199 
19202  HiddenLineAttributeKit & UnsetTransparencyCutoff();
19203 
19206  HiddenLineAttributeKit & UnsetEverything();
19207 
19208 
19212  bool ShowColor(RGBAColor & out_color) const;
19213 
19217  bool ShowDimFactor(float & out_zero_to_one) const;
19218 
19222  bool ShowFaceDisplacement(float & out_buckets) const;
19223 
19227  bool ShowLinePattern(UTF8 & out_pattern) const;
19228 
19232  bool ShowRenderFaces(bool & out_state) const;
19233 
19237  bool ShowRenderText(bool & out_state) const;
19238 
19242  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
19243 
19247  bool ShowSilhouetteCleanup(bool & out_state) const;
19248 
19252  bool ShowVisibility(bool & out_state) const;
19253 
19258  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
19259 
19263  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
19264 };
19265 
19266 
19272 class HPS_API HiddenLineAttributeControl : public Control
19273 {
19274 public:
19275 
19277  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
19278 
19281 
19286 
19291 
19294 
19295  virtual HPS::Type Type() const { return ObjectType(); }
19296 
19297  HPS::Type ObjectType() const {return HPS::Type::HiddenLineAttributeControl;};
19298 
19302  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
19303 
19307  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
19308 
19314  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
19315 
19325  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
19326 
19330  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
19331 
19335  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
19336 
19340  HiddenLineAttributeControl & SetRenderText(bool in_state);
19341 
19346  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
19347 
19353  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
19354 
19358  HiddenLineAttributeControl & SetVisibility(bool in_state);
19359 
19364  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
19365 
19371  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
19372 
19373 
19377  HiddenLineAttributeControl & UnsetColor();
19378 
19382  HiddenLineAttributeControl & UnsetDimFactor();
19383 
19387  HiddenLineAttributeControl & UnsetFaceDisplacement();
19388 
19392  HiddenLineAttributeControl & UnsetLinePattern();
19393 
19397  HiddenLineAttributeControl & UnsetRenderFaces();
19398 
19402  HiddenLineAttributeControl & UnsetRenderText();
19403 
19407  HiddenLineAttributeControl & UnsetAlgorithm();
19408 
19412  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
19413 
19417  HiddenLineAttributeControl & UnsetVisibility();
19418 
19422  HiddenLineAttributeControl & UnsetWeight();
19423 
19427  HiddenLineAttributeControl & UnsetTransparencyCutoff();
19428 
19432  HiddenLineAttributeControl & UnsetEverything();
19433 
19434 
19438  bool ShowColor(RGBAColor & out_color) const;
19439 
19443  bool ShowDimFactor(float & out_zero_to_one) const;
19444 
19448  bool ShowFaceDisplacement(float & out_buckets) const;
19449 
19453  bool ShowLinePattern(UTF8 & out_pattern) const;
19454 
19458  bool ShowRenderFaces(bool & out_state) const;
19459 
19463  bool ShowRenderText(bool & out_state) const;
19464 
19468  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
19469 
19473  bool ShowSilhouetteCleanup(bool & out_state) const;
19474 
19478  bool ShowVisibility(bool & out_state) const;
19479 
19484  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
19485 
19489  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
19490 
19491 private:
19494 };
19495 
19496 
19497 
19499 class HPS_API DrawingAttributeKit : public Kit
19500 {
19501 public:
19502 
19505 
19508  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
19509 
19514 
19518  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
19519 
19521  virtual ~DrawingAttributeKit();
19522 
19523  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeKit;};
19524 
19528  static DrawingAttributeKit GetDefault();
19529 
19532  void Set(DrawingAttributeKit const & in_kit);
19533 
19536  void Show(DrawingAttributeKit & out_kit) const;
19537 
19541  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
19542 
19545  bool Empty() const;
19546 
19550  bool Equals(DrawingAttributeKit const & in_kit) const;
19551 
19555  bool operator==(DrawingAttributeKit const & in_kit) const;
19556 
19560  bool operator!=(DrawingAttributeKit const & in_kit) const;
19561 
19577  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
19578 
19584  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
19585 
19598  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
19599 
19606  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
19607 
19612  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
19613 
19620  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
19621 
19626  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
19627 
19634  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
19635 
19639  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
19640 
19644  DrawingAttributeKit & SetVertexDecimation(float in_zero_to_one);
19645 
19649  DrawingAttributeKit & SetVertexRandomization(bool in_state);
19650 
19654  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
19655 
19660  DrawingAttributeKit & SetDeferral(int in_deferral);
19661 
19667  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
19668 
19675  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);
19676 
19682  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
19683 
19686  DrawingAttributeKit & UnsetPolygonHandedness();
19687 
19690  DrawingAttributeKit & UnsetWorldHandedness();
19691 
19694  DrawingAttributeKit & UnsetDepthRange();
19695 
19698  DrawingAttributeKit & UnsetFaceDisplacement();
19699 
19702  DrawingAttributeKit & UnsetGeneralDisplacement();
19703 
19706  DrawingAttributeKit & UnsetVertexDisplacement();
19707 
19710  DrawingAttributeKit & UnsetVertexDecimation();
19711 
19714  DrawingAttributeKit & UnsetVertexRandomization();
19715 
19718  DrawingAttributeKit & UnsetOverlay();
19719 
19722  DrawingAttributeKit & UnsetDeferral();
19723 
19726  DrawingAttributeKit & UnsetClipRegion();
19727 
19730  DrawingAttributeKit & UnsetEverything();
19731 
19735  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
19736 
19740  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
19741 
19746  bool ShowDepthRange(float & out_near, float & out_far) const;
19747 
19752  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
19753 
19758  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
19759 
19764  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
19765 
19769  bool ShowVertexDecimation(float & out_zero_to_one) const;
19770 
19774  bool ShowVertexRandomization(bool & out_state) const;
19775 
19779  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
19780 
19784  bool ShowDeferral(int & out_defer_batch) const;
19785 
19791  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
19792 
19793 };
19794 
19795 
19807 class HPS_API DrawingAttributeControl : public Control
19808 {
19809 public:
19810 
19812  explicit DrawingAttributeControl(SegmentKey & in_seg);
19813 
19816 
19821 
19825  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
19826 
19829 
19830  virtual HPS::Type Type() const { return ObjectType(); }
19831 
19832  HPS::Type ObjectType() const {return HPS::Type::DrawingAttributeControl;};
19833 
19837  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
19838 
19848  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
19849 
19855  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
19856 
19869  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
19870 
19877  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
19878 
19883  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
19884 
19891  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
19892 
19897  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
19898 
19905  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
19906 
19910  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
19911 
19915  DrawingAttributeControl & SetVertexDecimation(float in_zero_to_one);
19916 
19920  DrawingAttributeControl & SetVertexRandomization(bool in_state);
19921 
19925  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
19926 
19932  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
19933 
19940  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);
19941 
19947  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
19948 
19953  DrawingAttributeControl & SetDeferral(int in_deferral);
19954 
19958  DrawingAttributeControl & UnsetPolygonHandedness();
19959 
19963  DrawingAttributeControl & UnsetWorldHandedness();
19964 
19968  DrawingAttributeControl & UnsetDepthRange();
19969 
19973  DrawingAttributeControl & UnsetFaceDisplacement();
19974 
19978  DrawingAttributeControl & UnsetGeneralDisplacement();
19979 
19983  DrawingAttributeControl & UnsetVertexDisplacement();
19984 
19988  DrawingAttributeControl & UnsetVertexDecimation();
19989 
19993  DrawingAttributeControl & UnsetVertexRandomization();
19994 
19998  DrawingAttributeControl & UnsetOverlay();
19999 
20003  DrawingAttributeControl & UnsetDeferral();
20004 
20008  DrawingAttributeControl & UnsetClipRegion();
20009 
20013  DrawingAttributeControl & UnsetEverything();
20014 
20015 
20019  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
20020 
20024  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
20025 
20030  bool ShowDepthRange(float & out_x, float & out_y) const;
20031 
20036  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
20037 
20042  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
20043 
20048  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
20049 
20053  bool ShowVertexDecimation(float & out_zero_to_one) const;
20054 
20058  bool ShowVertexRandomization(bool & out_state) const;
20059 
20063  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
20064 
20068  bool ShowDeferral(int & out_defer_batch) const;
20069 
20075  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
20076 
20077 private:
20080 };
20081 
20082 
20084 class HPS_API PostProcessEffectsKit : public Kit
20085 {
20086 public:
20087 
20090 
20094 
20099 
20103  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
20104 
20106  virtual ~PostProcessEffectsKit();
20107 
20108  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsKit;};
20109 
20113  static PostProcessEffectsKit GetDefault();
20114 
20117  void Set(PostProcessEffectsKit const & in_kit);
20118 
20121  void Show(PostProcessEffectsKit & out_kit) const;
20122 
20126  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
20127 
20130  bool Empty() const;
20131 
20135  bool Equals(PostProcessEffectsKit const & in_kit) const;
20136 
20140  bool operator==(PostProcessEffectsKit const & in_kit) const;
20141 
20145  bool operator!=(PostProcessEffectsKit const & in_kit) const;
20146 
20147 
20157  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f);
20158 
20167  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f);
20168 
20175  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
20176 
20182  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
20183 
20190  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
20191 
20197  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
20198 
20206  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
20207 
20214  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
20215 
20223  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
20224 
20231  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
20232 
20236  PostProcessEffectsKit & SetWorldScale(float in_scale);
20237 
20240  PostProcessEffectsKit & UnsetAmbientOcclusion();
20241 
20244  PostProcessEffectsKit & UnsetBloom();
20245 
20248  PostProcessEffectsKit & UnsetDepthOfField();
20249 
20252  PostProcessEffectsKit & UnsetSilhouetteEdges();
20253 
20256  PostProcessEffectsKit & UnsetEyeDomeLighting();
20257 
20260  PostProcessEffectsKit & UnsetWorldScale();
20261 
20264  PostProcessEffectsKit & UnsetEverything();
20265 
20266 
20275  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality, float & out_radius) const;
20276 
20283  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
20284 
20291  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
20292 
20300  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
20301 
20309  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
20310 
20314  bool ShowWorldScale(float & out_scale) const;
20315 
20316 };
20317 
20318 
20322 class HPS_API PostProcessEffectsControl : public Control
20323 {
20324 public:
20325 
20327  explicit PostProcessEffectsControl(WindowKey & in_seg);
20328 
20331 
20336 
20340  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
20341 
20344 
20345  virtual HPS::Type Type() const { return ObjectType(); }
20346 
20347  HPS::Type ObjectType() const {return HPS::Type::PostProcessEffectsControl;};
20348 
20352  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
20353 
20363  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f);
20364 
20373  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest, float in_radius = 1.0f);
20374 
20381  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
20382 
20388  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
20389 
20396  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
20397 
20403  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
20404 
20412  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
20413 
20420  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
20421 
20429  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
20430 
20437  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
20438 
20442  PostProcessEffectsControl & SetWorldScale(float in_scale);
20443 
20447  PostProcessEffectsControl & UnsetAmbientOcclusion();
20448 
20452  PostProcessEffectsControl & UnsetBloom();
20453 
20457  PostProcessEffectsControl & UnsetDepthOfField();
20458 
20462  PostProcessEffectsControl & UnsetSilhouetteEdges();
20463 
20467  PostProcessEffectsControl & UnsetEyeDomeLighting();
20468 
20472  PostProcessEffectsControl & UnsetWorldScale();
20473 
20477  PostProcessEffectsControl & UnsetEverything();
20478 
20479 
20488  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality, float & out_radius) const;
20489 
20496  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
20497 
20504  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
20505 
20513  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
20514 
20522  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
20523 
20527  bool ShowWorldScale(float & out_scale) const;
20528 
20529 private:
20532 };
20533 
20535 class HPS_API TransformMaskKit : public Kit
20536 {
20537 public:
20538 
20540  TransformMaskKit();
20541 
20543  TransformMaskKit(TransformMaskKit const & in_kit);
20544 
20548  TransformMaskKit(TransformMaskKit && in_that);
20549 
20553  TransformMaskKit & operator=(TransformMaskKit && in_that);
20554 
20556  virtual ~TransformMaskKit();
20557 
20558  HPS::Type ObjectType() const {return HPS::Type::TransformMaskKit;};
20559 
20560  static TransformMaskKit GetDefault();
20561 
20563  void Set(TransformMaskKit const & in_kit);
20564 
20566  void Show(TransformMaskKit & out_kit) const;
20567 
20569  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
20570 
20572  bool Empty() const;
20573 
20575  bool Equals(TransformMaskKit const & in_kit) const;
20576 
20578  bool operator==(TransformMaskKit const & in_kit) const;
20579 
20581  bool operator!=(TransformMaskKit const & in_kit) const;
20582 
20583 
20587  TransformMaskKit & SetCameraRotation(bool in_state);
20588 
20592  TransformMaskKit & SetCameraScale(bool in_state);
20593 
20597  TransformMaskKit & SetCameraTranslation(bool in_state);
20598 
20602  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
20603 
20607  TransformMaskKit & SetCameraProjection(bool in_state);
20608 
20612  TransformMaskKit & SetCameraOffset(bool in_state);
20613 
20617  TransformMaskKit & SetCameraNearLimit(bool in_state);
20618 
20622  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
20623 
20627  TransformMaskKit & SetModellingMatrixScale(bool in_state);
20628 
20632  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
20633 
20637  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
20638 
20639 
20643  TransformMaskKit & SetCameraEverything(bool in_state);
20644 
20648  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
20649 
20653  TransformMaskKit & SetEverything(bool in_state);
20654 
20655 
20658  TransformMaskKit & UnsetCameraRotation();
20659 
20662  TransformMaskKit & UnsetCameraScale();
20663 
20666  TransformMaskKit & UnsetCameraTranslation();
20667 
20670  TransformMaskKit & UnsetCameraPerspectiveScale();
20671 
20674  TransformMaskKit & UnsetCameraProjection();
20675 
20678  TransformMaskKit & UnsetCameraOffset();
20679 
20682  TransformMaskKit & UnsetCameraNearLimit();
20683 
20686  TransformMaskKit & UnsetCameraEverything();
20687 
20690  TransformMaskKit & UnsetModellingMatrixRotation();
20691 
20694  TransformMaskKit & UnsetModellingMatrixScale();
20695 
20698  TransformMaskKit & UnsetModellingMatrixTranslation();
20699 
20702  TransformMaskKit & UnsetModellingMatrixOffset();
20703 
20706  TransformMaskKit & UnsetModellingMatrixEverything();
20707 
20710  TransformMaskKit & UnsetEverything();
20711 
20712 
20716  bool ShowCameraRotation(bool & out_state) const;
20717 
20721  bool ShowCameraScale(bool & out_state) const;
20722 
20726  bool ShowCameraTranslation(bool & out_state) const;
20727 
20731  bool ShowCameraPerspectiveScale(bool & out_state) const;
20732 
20736  bool ShowCameraProjection(bool & out_state) const;
20737 
20741  bool ShowCameraOffset(bool & out_state) const;
20742 
20746  bool ShowCameraNearLimit(bool & out_state) const;
20747 
20751  bool ShowModellingMatrixRotation(bool & out_state) const;
20752 
20756  bool ShowModellingMatrixScale(bool & out_state) const;
20757 
20761  bool ShowModellingMatrixTranslation(bool & out_state) const;
20762 
20766  bool ShowModellingMatrixOffset(bool & out_state) const;
20767 };
20768 
20769 
20774 class HPS_API TransformMaskControl : public Control
20775 {
20776 public:
20777 
20779  explicit TransformMaskControl(SegmentKey & in_seg);
20780 
20782  TransformMaskControl(TransformMaskControl const & in_that);
20783 
20788 
20792  TransformMaskControl & operator=(TransformMaskControl && in_that);
20793 
20796 
20797  virtual HPS::Type Type() const { return ObjectType(); }
20798 
20799  HPS::Type ObjectType() const {return HPS::Type::TransformMaskControl;};
20800 
20804  TransformMaskControl & operator=(TransformMaskControl const & in_that);
20805 
20809  TransformMaskControl & SetCameraRotation(bool in_state);
20810 
20814  TransformMaskControl & SetCameraScale(bool in_state);
20815 
20819  TransformMaskControl & SetCameraTranslation(bool in_state);
20820 
20824  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
20825 
20829  TransformMaskControl & SetCameraProjection(bool in_state);
20830 
20834  TransformMaskControl & SetCameraOffset(bool in_state);
20835 
20839  TransformMaskControl & SetCameraNearLimit(bool in_state);
20840 
20844  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
20845 
20849  TransformMaskControl & SetModellingMatrixScale(bool in_state);
20850 
20854  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
20855 
20859  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
20860 
20861 
20865  TransformMaskControl & SetCameraEverything(bool in_state);
20866 
20870  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
20871 
20875  TransformMaskControl & SetEverything(bool in_state);
20876 
20877 
20881  TransformMaskControl & UnsetCameraRotation();
20882 
20886  TransformMaskControl & UnsetCameraScale();
20887 
20891  TransformMaskControl & UnsetCameraTranslation();
20892 
20896  TransformMaskControl & UnsetCameraPerspectiveScale();
20897 
20901  TransformMaskControl & UnsetCameraProjection();
20902 
20906  TransformMaskControl & UnsetCameraOffset();
20907 
20911  TransformMaskControl & UnsetCameraNearLimit();
20912 
20916  TransformMaskControl & UnsetCameraEverything();
20917 
20921  TransformMaskControl & UnsetModellingMatrixRotation();
20922 
20926  TransformMaskControl & UnsetModellingMatrixScale();
20927 
20931  TransformMaskControl & UnsetModellingMatrixTranslation();
20932 
20936  TransformMaskControl & UnsetModellingMatrixOffset();
20937 
20941  TransformMaskControl & UnsetModellingMatrixEverything();
20942 
20946  TransformMaskControl & UnsetEverything();
20947 
20948 
20952  bool ShowCameraRotation(bool & out_state) const;
20953 
20957  bool ShowCameraScale(bool & out_state) const;
20958 
20962  bool ShowCameraTranslation(bool & out_state) const;
20963 
20967  bool ShowCameraPerspectiveScale(bool & out_state) const;
20968 
20972  bool ShowCameraProjection(bool & out_state) const;
20973 
20977  bool ShowCameraOffset(bool & out_state) const;
20978 
20982  bool ShowCameraNearLimit(bool & out_state) const;
20983 
20987  bool ShowModellingMatrixRotation(bool & out_state) const;
20988 
20992  bool ShowModellingMatrixScale(bool & out_state) const;
20993 
20997  bool ShowModellingMatrixTranslation(bool & out_state) const;
20998 
21002  bool ShowModellingMatrixOffset(bool & out_state) const;
21003 
21004 private:
21007 };
21008 
21009 
21010 
21012 class HPS_API VisualEffectsKit : public Kit
21013 {
21014 public:
21015 
21017  VisualEffectsKit();
21018 
21021  VisualEffectsKit(VisualEffectsKit const & in_kit);
21022 
21026  VisualEffectsKit(VisualEffectsKit && in_that);
21027 
21031  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
21032 
21034  virtual ~VisualEffectsKit();
21035 
21036  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsKit;};
21037 
21041  static VisualEffectsKit GetDefault();
21042 
21045  void Set(VisualEffectsKit const & in_kit);
21046 
21049  void Show(VisualEffectsKit & out_kit) const;
21050 
21054  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
21055 
21058  bool Empty() const;
21059 
21063  bool Equals(VisualEffectsKit const & in_kit) const;
21064 
21068  bool operator==(VisualEffectsKit const & in_kit) const;
21069 
21073  bool operator!=(VisualEffectsKit const & in_kit) const;
21074 
21078  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
21079 
21083  VisualEffectsKit & SetAmbientOcclusionEnabled(bool in_state);
21084 
21088  VisualEffectsKit & SetBloomEnabled(bool in_state);
21089 
21093  VisualEffectsKit & SetDepthOfFieldEnabled(bool in_state);
21094 
21098  VisualEffectsKit & SetSilhouetteEdgesEnabled(bool in_state);
21099 
21103  VisualEffectsKit & SetEyeDomeLightingEnabled(bool in_state);
21104 
21110  VisualEffectsKit & SetEyeDomeLightingBackColor(bool in_state, RGBColor const & in_color = RGBColor::Black());
21111 
21116  VisualEffectsKit & SetEyeDomeLightingBackColor(RGBColor const & in_color);
21117 
21121  VisualEffectsKit & SetAntiAliasing(bool in_state);
21122 
21132  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
21133 
21142  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
21143 
21150  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
21151 
21157  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
21158 
21162  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
21163 
21167  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
21168 
21172  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
21173 
21184  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);
21185 
21195  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
21196 
21200  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
21201 
21205  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
21206 
21209  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
21210 
21213  VisualEffectsKit & UnsetAmbientOcclusionEnabled();
21214 
21217  VisualEffectsKit & UnsetSilhouetteEdgesEnabled();
21218 
21221  VisualEffectsKit & UnsetDepthOfFieldEnabled();
21222 
21225  VisualEffectsKit & UnsetBloomEnabled();
21226 
21229  VisualEffectsKit & UnsetEyeDomeLightingEnabled();
21230 
21233  VisualEffectsKit & UnsetEyeDomeLightingBackColor();
21234 
21237  VisualEffectsKit & UnsetAntiAliasing();
21238 
21241  VisualEffectsKit & UnsetShadowMaps();
21242 
21245  VisualEffectsKit & UnsetSimpleShadow();
21246 
21249  VisualEffectsKit & UnsetSimpleShadowPlane();
21250 
21253  VisualEffectsKit & UnsetSimpleShadowLightDirection();
21254 
21257  VisualEffectsKit & UnsetSimpleShadowColor();
21258 
21261  VisualEffectsKit & UnsetSimpleReflection();
21262 
21265  VisualEffectsKit & UnsetSimpleReflectionPlane();
21266 
21269  VisualEffectsKit & UnsetSimpleReflectionVisibility();
21270 
21273  VisualEffectsKit & UnsetEverything();
21274 
21278  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
21279 
21283  bool ShowAmbientOcclusionEnabled(bool & out_state) const;
21284 
21288  bool ShowSilhouetteEdgesEnabled(bool & out_state) const;
21289 
21293  bool ShowDepthOfFieldEnabled(bool & out_state) const;
21294 
21298  bool ShowBloomEnabled(bool & out_state) const;
21299 
21303  bool ShowEyeDomeLightingEnabled(bool & out_state) const;
21304 
21309  bool ShowEyeDomeLightingBackColor(bool & out_state, RGBColor & out_color) const;
21310 
21314  bool ShowAntiAliasing(bool & out_state) const;
21315 
21323  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
21324 
21331  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
21332 
21336  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
21337 
21341  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
21342 
21346  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
21347 
21356  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;
21357 
21358 
21362  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
21363 
21367  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
21368 };
21369 
21370 
21376 class HPS_API VisualEffectsControl : public Control
21377 {
21378 public:
21379 
21381  explicit VisualEffectsControl(SegmentKey & in_seg);
21382 
21384  VisualEffectsControl(VisualEffectsControl const & in_that);
21385 
21390 
21394  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
21395 
21398 
21399  virtual HPS::Type Type() const { return ObjectType(); }
21400 
21401  HPS::Type ObjectType() const {return HPS::Type::VisualEffectsControl;};
21402 
21406  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
21407 
21411  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
21412 
21416  VisualEffectsControl & SetAmbientOcclusionEnabled(bool in_state);
21417 
21421  VisualEffectsControl & SetSilhouetteEdgesEnabled(bool in_state);
21422 
21426  VisualEffectsControl & SetDepthOfFieldEnabled(bool in_state);
21427 
21431  VisualEffectsControl & SetBloomEnabled(bool in_state);
21432 
21436  VisualEffectsControl & SetEyeDomeLightingEnabled(bool in_state);
21437 
21443  VisualEffectsControl & SetEyeDomeLightingBackColor(bool in_state, RGBColor const & in_color = RGBColor::Black());
21444 
21449  VisualEffectsControl & SetEyeDomeLightingBackColor(RGBColor const & in_color);
21450 
21454  VisualEffectsControl & SetAntiAliasing(bool in_state);
21455 
21465  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
21466 
21475  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
21476 
21483  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
21484 
21490  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
21491 
21495  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
21496 
21500  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
21501 
21505  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
21506 
21517  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);
21518 
21528  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
21529 
21533  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
21534 
21538  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
21539 
21540 
21544  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
21545 
21549  VisualEffectsControl & UnsetAmbientOcclusionEnabled();
21550 
21554  VisualEffectsControl & UnsetSilhouetteEdgesEnabled();
21555 
21559  VisualEffectsControl & UnsetDepthOfFieldEnabled();
21560 
21564  VisualEffectsControl & UnsetBloomEnabled();
21565 
21569  VisualEffectsControl & UnsetEyeDomeLightingEnabled();
21570 
21574  VisualEffectsControl & UnsetEyeDomeLightingBackColor();
21575 
21579  VisualEffectsControl & UnsetAntiAliasing();
21580 
21584  VisualEffectsControl & UnsetShadowMaps();
21585 
21589  VisualEffectsControl & UnsetSimpleShadow();
21590 
21594  VisualEffectsControl & UnsetSimpleShadowPlane();
21595 
21599  VisualEffectsControl & UnsetSimpleShadowLightDirection();
21600 
21604  VisualEffectsControl & UnsetSimpleShadowColor();
21605 
21609  VisualEffectsControl & UnsetSimpleReflection();
21610 
21614  VisualEffectsControl & UnsetSimpleReflectionPlane();
21615 
21619  VisualEffectsControl & UnsetSimpleReflectionVisibility();
21620 
21624  VisualEffectsControl & UnsetEverything();
21625 
21626 
21630  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
21631 
21635  bool ShowAmbientOcclusionEnabled(bool & out_state) const;
21636 
21640  bool ShowSilhouetteEdgesEnabled(bool & out_state) const;
21641 
21645  bool ShowDepthOfFieldEnabled(bool & out_state) const;
21646 
21650  bool ShowBloomEnabled(bool & out_state) const;
21651 
21655  bool ShowEyeDomeLightingEnabled(bool & out_state) const;
21656 
21661  bool ShowEyeDomeLightingBackColor(bool & out_state, RGBColor & out_color) const;
21662 
21666  bool ShowAntiAliasing(bool & out_state) const;
21667 
21675  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
21676 
21683  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
21684 
21688  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
21689 
21693  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
21694 
21698  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
21699 
21708  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;
21709 
21713  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
21714 
21718  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
21719 
21720 private:
21723 };
21724 
21725 
21726 
21728 class HPS_API ContourLineKit : public Kit
21729 {
21730 public:
21731 
21733  ContourLineKit();
21734 
21737  ContourLineKit(ContourLineKit const & in_kit);
21738 
21742  ContourLineKit(ContourLineKit && in_that);
21743 
21747  ContourLineKit & operator=(ContourLineKit && in_that);
21748 
21750  virtual ~ContourLineKit();
21751 
21752  HPS::Type ObjectType() const { return HPS::Type::ContourLineKit; };
21753 
21757  static ContourLineKit GetDefault();
21758 
21761  void Set(ContourLineKit const & in_kit);
21762 
21765  void Show(ContourLineKit & out_kit) const;
21766 
21770  ContourLineKit & operator=(ContourLineKit const & in_kit);
21771 
21774  bool Empty() const;
21775 
21779  bool Equals(ContourLineKit const & in_kit) const;
21780 
21784  bool operator==(ContourLineKit const & in_kit) const;
21785 
21789  bool operator!=(ContourLineKit const & in_kit) const;
21790 
21791 
21795  ContourLineKit & SetVisibility(bool in_state);
21796 
21801  ContourLineKit & SetPositions(float in_interval, float in_offset);
21802 
21806  ContourLineKit & SetPositions(FloatArray const & in_positions);
21807 
21812  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
21813 
21817  ContourLineKit & SetColors(RGBColorArray const & in_colors);
21818 
21823  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
21824 
21828  ContourLineKit & SetColors(RGBColor const & in_color);
21829 
21833  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
21834 
21839  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
21840 
21844  ContourLineKit & SetPatterns(char const * in_pattern);
21845 
21850  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
21851 
21857  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
21858 
21863  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
21864 
21868  ContourLineKit & SetLighting(bool in_state);
21869 
21870 
21873  ContourLineKit & UnsetVisibility();
21874 
21877  ContourLineKit & UnsetPositions();
21878 
21881  ContourLineKit & UnsetColors();
21882 
21885  ContourLineKit & UnsetPatterns();
21886 
21889  ContourLineKit & UnsetWeights();
21890 
21893  ContourLineKit & UnsetLighting();
21894 
21897  ContourLineKit & UnsetEverything();
21898 
21899 
21903  bool ShowVisibility(bool & out_state) const;
21904 
21910  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
21911 
21915  bool ShowColors(RGBColorArray & out_colors) const;
21916 
21920  bool ShowPatterns(UTF8Array & out_patterns) const;
21921 
21926  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
21927 
21931  bool ShowLighting(bool & out_state) const;
21932 };
21933 
21937 class HPS_API ContourLineControl : public Control
21938 {
21939 public:
21940 
21942  explicit ContourLineControl(SegmentKey & in_seg);
21943 
21945  ContourLineControl(ContourLineControl const & in_that);
21946 
21951 
21955  ContourLineControl & operator=(ContourLineControl && in_that);
21956 
21958  ~ContourLineControl();
21959 
21960  virtual HPS::Type Type() const { return ObjectType(); }
21961 
21962  HPS::Type ObjectType() const { return HPS::Type::ContourLineControl; };
21963 
21967  ContourLineControl & operator=(ContourLineControl const & in_that);
21968 
21972  ContourLineControl & SetVisibility(bool in_state);
21973 
21978  ContourLineControl & SetPositions(float in_interval, float in_offset);
21979 
21983  ContourLineControl & SetPositions(FloatArray const & in_positions);
21984 
21989  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
21990 
21994  ContourLineControl & SetColors(RGBColorArray const & in_colors);
21995 
22000  ContourLineControl & SetColors(size_t in_count, RGBColor const in_colors[]);
22001 
22005  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
22006 
22010  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
22011 
22016  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
22017 
22021  ContourLineControl & SetPatterns(char const * in_pattern);
22022 
22027  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
22028 
22034  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
22035 
22040  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
22041 
22045  ContourLineControl & SetLighting(bool in_state);
22046 
22047 
22051  ContourLineControl & UnsetVisibility();
22052 
22056  ContourLineControl & UnsetPositions();
22057 
22061  ContourLineControl & UnsetColors();
22062 
22066  ContourLineControl & UnsetPatterns();
22067 
22071  ContourLineControl & UnsetWeights();
22072 
22076  ContourLineControl & UnsetLighting();
22077 
22081  ContourLineControl & UnsetEverything();
22082 
22083 
22087  bool ShowVisibility(bool & out_state) const;
22088 
22094  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
22095 
22099  bool ShowColors(RGBColorArray & out_colors) const;
22100 
22104  bool ShowPatterns(UTF8Array & out_patterns) const;
22105 
22110  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
22111 
22115  bool ShowLighting(bool & out_state) const;
22116 
22117 private:
22120 };
22121 
22122 
22123 
22125 class HPS_API SubwindowKit : public Kit
22126 {
22127 public:
22128 
22130  SubwindowKit();
22131 
22133  SubwindowKit(SubwindowKit const & in_kit);
22134 
22138  SubwindowKit(SubwindowKit && in_that);
22139 
22143  SubwindowKit & operator=(SubwindowKit && in_that);
22144 
22146  virtual ~SubwindowKit();
22147 
22148  HPS::Type ObjectType() const {return HPS::Type::SubwindowKit;}
22149 
22153  static SubwindowKit GetDefault();
22154 
22157  void Set(SubwindowKit const & in_kit);
22158 
22161  void Show(SubwindowKit & out_kit) const;
22162 
22166  SubwindowKit & operator=(SubwindowKit const & in_kit);
22167 
22170  bool Empty() const;
22171 
22175  bool Equals(SubwindowKit const & in_kit) const;
22176 
22180  bool operator==(SubwindowKit const & in_kit) const;
22181 
22185  bool operator!=(SubwindowKit const & in_kit) const;
22186 
22187 
22197  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
22198 
22199 
22210  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, IntRectangle const & in_subwindow_offsets, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
22211 
22212 
22219  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
22220 
22225  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
22226 
22231  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
22232 
22238  SubwindowKit & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
22239 
22244  SubwindowKit & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
22245 
22248  SubwindowKit & UnsetSubwindow();
22249 
22252  SubwindowKit & UnsetBackground();
22253 
22256  SubwindowKit & UnsetBorder();
22257 
22260  SubwindowKit & UnsetRenderingAlgorithm();
22261 
22264  SubwindowKit & UnsetModelCompareMode();
22265 
22268  SubwindowKit & UnsetEverything();
22269 
22275  bool ShowSubwindow(Rectangle & out_subwindow_position, IntRectangle & out_subwindow_offsets, Subwindow::Type & out_subwindow_type) const;
22276 
22282  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
22283 
22288  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
22289 
22293  bool ShowBorder(Subwindow::Border & out_border_type) const;
22294 
22298  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
22299 
22305  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
22306 };
22307 
22308 
22309 
22315 class HPS_API SubwindowControl : public Control
22316 {
22317 public:
22318 
22320  explicit SubwindowControl(SegmentKey & in_seg);
22321 
22323  SubwindowControl(SubwindowControl const & in_that);
22324 
22328  SubwindowControl(SubwindowControl && in_that);
22329 
22333  SubwindowControl & operator=(SubwindowControl && in_that);
22334 
22336  ~SubwindowControl();
22337 
22338  virtual HPS::Type Type() const { return ObjectType(); }
22339 
22340  HPS::Type ObjectType() const {return HPS::Type::SubwindowControl;}
22341 
22345  SubwindowControl & operator=(SubwindowControl const & in_that);
22346 
22357  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
22358 
22370  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, IntRectangle const & in_window_offsets, Subwindow::Type in_type = Subwindow::Type::Standard);
22371 
22378  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
22379 
22384  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
22385 
22391  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
22392 
22398  SubwindowControl & SetModelCompareMode(bool in_state, SegmentKey const & in_source1 = SegmentKey(), SegmentKey const & in_source2 = SegmentKey());
22399 
22404  SubwindowControl & SetModelCompareMode(SegmentKey const & in_source1, SegmentKey const & in_source2);
22405 
22409  SubwindowControl & UnsetSubwindow();
22410 
22414  SubwindowControl & UnsetBackground();
22415 
22419  SubwindowControl & UnsetBorder();
22420 
22424  SubwindowControl & UnsetRenderingAlgorithm();
22425 
22429  SubwindowControl & UnsetModelCompareMode();
22430 
22434  SubwindowControl & UnsetEverything();
22435 
22441  bool ShowSubwindow(Rectangle & out_subwindow_position, IntRectangle & out_subwindow_offsets, Subwindow::Type & out_subwindow_type) const;
22442 
22448  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
22449 
22454  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
22455 
22459  bool ShowBorder(Subwindow::Border & out_border_type) const;
22460 
22464  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
22465 
22471  bool ShowModelCompareMode(bool & out_state, SegmentKey & out_source1, SegmentKey & out_source2) const;
22472 
22473 private:
22475  SubwindowControl();
22476 };
22477 
22478 
22479 
22481 class HPS_API DebuggingKit : public Kit
22482 {
22483 public:
22484 
22486  DebuggingKit();
22487 
22489  DebuggingKit(DebuggingKit const & in_kit);
22490 
22494  DebuggingKit(DebuggingKit && in_that);
22495 
22499  DebuggingKit & operator=(DebuggingKit && in_that);
22500 
22502  virtual ~DebuggingKit();
22503 
22504  HPS::Type ObjectType() const {return HPS::Type::DebuggingKit;}
22505 
22509  static DebuggingKit GetDefault();
22510 
22513  void Set(DebuggingKit const & in_kit);
22514 
22517  void Show(DebuggingKit & out_kit) const;
22518 
22522  DebuggingKit & operator=(DebuggingKit const & in_kit);
22523 
22526  bool Empty() const;
22527 
22531  bool Equals(DebuggingKit const & in_kit) const;
22532 
22536  bool operator==(DebuggingKit const & in_kit) const;
22537 
22541  bool operator!=(DebuggingKit const & in_kit) const;
22542 
22543 
22547  DebuggingKit & SetResourceMonitor(bool in_display);
22548 
22549 
22552  DebuggingKit & UnsetResourceMonitor();
22553 
22556  DebuggingKit & UnsetEverything();
22557 
22558 
22562  bool ShowResourceMonitor(bool & out_display) const;
22563 };
22564 
22565 
22568 class HPS_API DebuggingControl : public Control
22569 {
22570 public:
22571 
22573  explicit DebuggingControl(WindowKey & in_window);
22574 
22576  DebuggingControl(DebuggingControl const & in_that);
22577 
22581  DebuggingControl(DebuggingControl && in_that);
22582 
22586  DebuggingControl & operator=(DebuggingControl && in_that);
22587 
22589  ~DebuggingControl();
22590 
22591  virtual HPS::Type Type() const { return ObjectType(); }
22592 
22593  HPS::Type ObjectType() const {return HPS::Type::DebuggingControl;}
22594 
22598  DebuggingControl & operator=(DebuggingControl const & in_that);
22599 
22604  DebuggingControl & SetResourceMonitor(bool in_display);
22605 
22609  DebuggingControl & UnsetResourceMonitor();
22610 
22614  DebuggingControl & UnsetEverything();
22615 
22619  bool ShowResourceMonitor(bool & out_display) const;
22620 
22621 private:
22623  DebuggingControl();
22624 };
22625 
22626 
22628 class HPS_API WindowInfoKit : public Kit
22629 {
22630 public:
22631 
22633  WindowInfoKit();
22634 
22636  WindowInfoKit(WindowInfoKit const & in_kit);
22637 
22641  WindowInfoKit(WindowInfoKit && in_that);
22642 
22646  WindowInfoKit & operator=(WindowInfoKit && in_that);
22647 
22649  virtual ~WindowInfoKit();
22650 
22651  HPS::Type ObjectType() const {return HPS::Type::WindowInfoKit;}
22652 
22655  void Set(WindowInfoKit const & in_kit);
22656 
22659  void Show(WindowInfoKit & out_kit) const;
22660 
22664  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
22665 
22668  bool Empty() const;
22669 
22673  bool Equals(WindowInfoKit const & in_kit) const;
22674 
22678  bool operator==(WindowInfoKit const & in_kit) const;
22679 
22683  bool operator!=(WindowInfoKit const & in_kit) const;
22684 
22685 
22690  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
22691 
22696  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
22697 
22702  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
22703 
22708  WindowInfoKit & SetWindowSize(float in_width, float in_height);
22709 
22710 
22713  WindowInfoKit & UnsetPhysicalPixels();
22714 
22717  WindowInfoKit & UnsetPhysicalSize();
22718 
22721  WindowInfoKit & UnsetWindowPixels();
22722 
22725  WindowInfoKit & UnsetWindowSize();
22726 
22729  WindowInfoKit & UnsetEverything();
22730 
22731 
22736  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
22737 
22742  bool ShowPhysicalSize(float & out_width, float & out_height) const;
22743 
22748  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
22749 
22754  bool ShowWindowSize(float & out_width, float & out_height) const;
22755 
22761  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
22762 
22766  bool ShowWindowAspectRatio(float & out_window_aspect) const;
22767 
22771  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
22772 };
22773 
22774 
22777 class HPS_API WindowInfoControl : public Control
22778 {
22779 public:
22780 
22782  explicit WindowInfoControl(WindowKey & in_window);
22783 
22785  WindowInfoControl(WindowInfoControl const & in_that);
22786 
22791 
22795  WindowInfoControl & operator=(WindowInfoControl && in_that);
22796 
22798  ~WindowInfoControl();
22799 
22800  virtual HPS::Type Type() const { return ObjectType(); }
22801 
22802  HPS::Type ObjectType() const {return HPS::Type::WindowInfoControl;}
22803 
22807  WindowInfoControl & operator=(WindowInfoControl const & in_that);
22808 
22813  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
22814 
22819  bool ShowPhysicalSize(float & out_width, float & out_height) const;
22820 
22825  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
22826 
22831  bool ShowWindowSize(float & out_width, float & out_height) const;
22832 
22838  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
22839 
22843  bool ShowWindowAspectRatio(float & out_window_aspect) const;
22844 
22848  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
22849 
22854  bool ShowMaxTextureSize(unsigned int & out_width, unsigned int & out_height) const;
22855 
22860  bool ShowLastUpdateTime(Time & out_time) const;
22861 
22865  bool ShowDepthPeelingLayers(size_t & out_layers) const;
22866 
22870  bool ShowVideoMemory(size_t & out_video_memory) const;
22871 
22875  bool ShowDepthBufferSize(size_t & out_bits) const;
22876 
22880  bool ShowMaxLights(size_t & out_lights) const;
22881 
22885  bool ShowColorBitPlanes(size_t & out_planes) const;
22886 
22890  bool ShowLastUpdateInfo(UpdateInfo & out_info) const;
22891 
22895  bool ShowGPUName(UTF8 & out_name) const;
22896 
22897 private:
22900 };
22901 
22903 class HPS_API FontInfoState : public Object
22904 {
22905 public:
22906 
22908  FontInfoState();
22909 
22911  FontInfoState(FontInfoState const & in_kit);
22912 
22916  FontInfoState(FontInfoState && in_that);
22917 
22921  FontInfoState & operator=(FontInfoState && in_that);
22922 
22924  virtual ~FontInfoState();
22925 
22926  HPS::Type ObjectType() const {return HPS::Type::FontInfoState;}
22927 
22930  void Assign(FontInfoState const & in_that);
22931 
22934  void Set(FontInfoState const & in_kit);
22935 
22938  void Show(FontInfoState & out_kit) const;
22939 
22943  FontInfoState & operator=(FontInfoState const & in_kit);
22944 
22947  bool Empty() const;
22948 
22952  bool Equals(FontInfoState const & in_kit) const;
22953 
22957  bool operator==(FontInfoState const & in_kit) const;
22958 
22962  bool operator!=(FontInfoState const & in_kit) const;
22963 
22966  UTF8 GetName() const;
22967 
22970  bool ShowSystemName(HPS::UTF8 & out_name) const;
22971 
22974  bool GetShellConvertibility() const;
22975 };
22976 
22977 
22982 class HPS_API AttributeLockKit : public Kit
22983 {
22984 public:
22985 
22987  AttributeLockKit();
22988 
22990  AttributeLockKit(AttributeLockKit const & in_kit);
22991 
22995  AttributeLockKit(AttributeLockKit && in_that);
22996 
23000  AttributeLockKit & operator=(AttributeLockKit && in_that);
23001 
23003  virtual ~AttributeLockKit();
23004 
23005  HPS::Type ObjectType() const {return HPS::Type::AttributeLockKit;}
23006 
23010  static AttributeLockKit GetDefault();
23011 
23014  void Set(AttributeLockKit const & in_kit);
23015 
23018  void Show(AttributeLockKit & out_kit) const;
23019 
23023  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
23024 
23027  bool Empty() const;
23028 
23032  bool Equals(AttributeLockKit const & in_kit) const;
23033 
23037  bool operator==(AttributeLockKit const & in_kit) const;
23038 
23042  bool operator!=(AttributeLockKit const & in_kit) const;
23043 
23049  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
23050 
23055  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
23056 
23062  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
23063 
23069  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
23070 
23071 
23074  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
23075 
23078  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
23079 
23082  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
23083 
23086  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
23087 
23090  AttributeLockKit & UnsetEverything();
23091 
23092 
23097  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
23098 
23103  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
23104 
23109  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
23110 
23115  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
23116 };
23117 
23118 
23123 class HPS_API AttributeLockControl : public Control
23124 {
23125 public:
23126 
23128  explicit AttributeLockControl(SegmentKey & in_seg);
23129 
23134 
23138  AttributeLockControl & operator=(AttributeLockControl && in_that);
23139 
23141  AttributeLockControl(AttributeLockControl const & in_that);
23142 
23145 
23146  virtual HPS::Type Type() const { return ObjectType(); }
23147 
23148  HPS::Type ObjectType() const {return HPS::Type::AttributeLockControl;}
23149 
23153  AttributeLockControl & operator=(AttributeLockControl const & in_that);
23154 
23160  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
23161 
23166  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
23167 
23173  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
23174 
23180  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
23181 
23182 
23186  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
23187 
23191  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
23192 
23196  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
23197 
23201  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
23202 
23206  AttributeLockControl & UnsetEverything();
23207 
23208 
23213  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
23214 
23219  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
23220 
23225  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
23226 
23231  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
23232 
23233 private:
23236 };
23237 
23241 
23242 class HPS_API GeometryKey : public Key
23243 {
23244 public:
23246  GeometryKey();
23247 
23251  explicit GeometryKey(Key const & in_that);
23252 
23255  GeometryKey(GeometryKey const & in_that);
23256 
23260  GeometryKey & operator=(GeometryKey const & in_that);
23261 
23265  GeometryKey(GeometryKey && in_that);
23266 
23270  GeometryKey & operator=(GeometryKey && in_that);
23271 
23272  ~GeometryKey();
23273 
23274  HPS::Type ObjectType() const { return HPS::Type::GeometryKey; };
23275 
23276 
23280  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
23281 
23285  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
23286 
23287 
23288 
23295  GeometryKey & SetPriority(int in_priority);
23296 
23299  GeometryKey & UnsetPriority();
23300 
23304  bool ShowPriority(int & out_priority) const;
23305 
23306 
23312  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23313 
23318  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
23319 
23324  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23325 
23329  GeometryKey & UnsetUserData(intptr_t in_index);
23330 
23335  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23336 
23340  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
23341 
23344  GeometryKey & UnsetAllUserData();
23345 
23347  size_t ShowUserDataCount() const;
23348 
23352  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23353 
23358  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23359 
23364  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23365 
23370  bool ShowBounding(BoundingKit & out_kit) const;
23371 };
23372 
23373 
23375 class HPS_API LineKit : public Kit
23376 {
23377 public:
23379  LineKit();
23380 
23383  LineKit(LineKit const & in_kit);
23384 
23388  LineKit(LineKit && in_that);
23389 
23393  LineKit & operator=(LineKit && in_that);
23394 
23395  virtual ~LineKit();
23396 
23397  HPS::Type ObjectType() const { return HPS::Type::LineKit; };
23398 
23401  void Consume(LineKit & in_kit);
23402 
23405  void Set(LineKit const & in_kit);
23406 
23409  void Show(LineKit & out_kit) const;
23410 
23414  LineKit & operator=(LineKit const & in_kit);
23415 
23418  bool Empty() const;
23419 
23423  bool Equals(LineKit const & in_kit) const;
23424 
23428  bool operator==(LineKit const & in_kit) const;
23429 
23433  bool operator!=(LineKit const & in_kit) const;
23434 
23437  size_t GetPointCount() const;
23438 
23445  LineKit & SetPriority(int in_priority);
23446 
23449  LineKit & UnsetPriority();
23450 
23454  bool ShowPriority(int & out_priority) const;
23455 
23456 
23460  LineKit & SetPoints(PointArray const & in_points);
23461 
23466  LineKit & SetPoints(size_t in_count, Point const in_points []);
23467 
23468 
23471  LineKit & UnsetPoints();
23472 
23475  LineKit & UnsetEverything();
23476 
23477 
23481  bool ShowPoints(PointArray & out_points) const;
23482 
23488  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23489 
23494  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23495 
23501  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23502 
23503 
23509  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23510 
23515  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23516 
23521  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
23522 
23528  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23529 
23535  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23536 
23542  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23543 
23548  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23549 
23554  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23555 
23559  LineKit & UnsetUserData(intptr_t in_index);
23560 
23565  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23566 
23570  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
23571 
23574  LineKit & UnsetAllUserData();
23575 
23577  size_t ShowUserDataCount() const;
23578 
23582  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23583 
23588  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23589 
23594  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23595 };
23596 
23598 class HPS_API LineKey : public GeometryKey
23599 {
23600 public:
23602  LineKey();
23603 
23607  explicit LineKey(Key const & in_that);
23608 
23611  LineKey(LineKey const & in_that);
23612 
23616  LineKey & operator=(LineKey const & in_that);
23617 
23621  LineKey(LineKey && in_that);
23622 
23626  LineKey & operator=(LineKey && in_that);
23627 
23628  ~LineKey();
23629 
23630  HPS::Type ObjectType() const { return HPS::Type::LineKey; };
23631 
23632 
23635  void Consume(LineKit & in_kit);
23636 
23639  void Set(LineKit const & in_kit);
23640 
23643  void Show(LineKit & out_kit) const;
23644 
23647  size_t GetPointCount() const;
23648 
23652  LineKey & SetPoints(PointArray const & in_points);
23653 
23658  LineKey & SetPoints(size_t in_count, Point const in_points []);
23659 
23660 
23664  bool ShowPoints(PointArray & out_points) const;
23665 
23671  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
23672 
23677  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
23678 
23684  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
23685 
23686 
23692  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
23693 
23698  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
23699 
23704  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
23705 
23711  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
23712 
23718  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
23719 };
23720 
23721 
23722 
23724 class HPS_API MarkerKit : public Kit
23725 {
23726 public:
23728  MarkerKit();
23729 
23732  MarkerKit(MarkerKit const & in_kit);
23733 
23737  MarkerKit(MarkerKit && in_that);
23738 
23742  MarkerKit & operator=(MarkerKit && in_that);
23743 
23744  virtual ~MarkerKit();
23745 
23746  HPS::Type ObjectType() const { return HPS::Type::MarkerKit; };
23747 
23750  void Consume(MarkerKit & in_kit);
23751 
23754  void Set(MarkerKit const & in_kit);
23755 
23758  void Show(MarkerKit & out_kit) const;
23759 
23763  MarkerKit & operator=(MarkerKit const & in_kit);
23764 
23767  bool Empty() const;
23768 
23772  bool Equals(MarkerKit const & in_kit) const;
23773 
23777  bool operator==(MarkerKit const & in_kit) const;
23778 
23782  bool operator!=(MarkerKit const & in_kit) const;
23783 
23784 
23791  MarkerKit & SetPriority(int in_priority);
23792 
23795  MarkerKit & UnsetPriority();
23796 
23800  bool ShowPriority(int & out_priority) const;
23801 
23805  MarkerKit & SetPoint(Point const & in_point);
23806 
23807 
23810  MarkerKit & UnsetPoint();
23811 
23814  MarkerKit & UnsetEverything();
23815 
23816 
23820  bool ShowPoint(HPS::Point & out_point) const;
23821 
23827  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23828 
23833  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23834 
23839  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23840 
23844  MarkerKit & UnsetUserData(intptr_t in_index);
23845 
23850  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23851 
23855  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
23856 
23859  MarkerKit & UnsetAllUserData();
23860 
23862  size_t ShowUserDataCount() const;
23863 
23867  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23868 
23873  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23874 
23879  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23880 };
23881 
23883 class HPS_API MarkerKey : public GeometryKey
23884 {
23885 public:
23887  MarkerKey();
23888 
23892  explicit MarkerKey(Key const & in_that);
23893 
23896  MarkerKey(MarkerKey const & in_that);
23897 
23901  MarkerKey & operator=(MarkerKey const & in_that);
23902 
23906  MarkerKey(MarkerKey && in_that);
23907 
23911  MarkerKey & operator=(MarkerKey && in_that);
23912 
23913  ~MarkerKey();
23914 
23915  HPS::Type ObjectType() const { return HPS::Type::MarkerKey; };
23916 
23917 
23920  void Consume(MarkerKit & in_kit);
23921 
23924  void Set(MarkerKit const & in_kit);
23925 
23928  void Show(MarkerKit & out_kit) const;
23929 
23930 
23934  MarkerKey & SetPoint(Point const & in_point);
23935 
23939  bool ShowPoint(Point & out_point) const;
23940 };
23941 
23942 
23943 
23945 class HPS_API DistantLightKit : public Kit
23946 {
23947 public:
23949  DistantLightKit();
23950 
23953  DistantLightKit(DistantLightKit const & in_kit);
23954 
23958  DistantLightKit(DistantLightKit && in_that);
23959 
23963  DistantLightKit & operator=(DistantLightKit && in_that);
23964 
23965  virtual ~DistantLightKit();
23966 
23967  HPS::Type ObjectType() const { return HPS::Type::DistantLightKit; };
23968 
23971  void Consume(DistantLightKit & in_kit);
23972 
23975  void Set(DistantLightKit const & in_kit);
23976 
23979  void Show(DistantLightKit & out_kit) const;
23980 
23984  DistantLightKit & operator=(DistantLightKit const & in_kit);
23985 
23988  bool Empty() const;
23989 
23993  bool Equals(DistantLightKit const & in_kit) const;
23994 
23998  bool operator==(DistantLightKit const & in_kit) const;
23999 
24003  bool operator!=(DistantLightKit const & in_kit) const;
24004 
24005 
24012  DistantLightKit & SetPriority(int in_priority);
24013 
24019  DistantLightKit & SetDirection(HPS::Vector const & in_vector);
24020 
24024  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
24025 
24029  DistantLightKit & SetColorByIndex(float in_index);
24030 
24036  DistantLightKit & SetCameraRelative(bool in_state);
24037 
24038 
24041  DistantLightKit & UnsetPriority();
24042 
24045  DistantLightKit & UnsetDirection();
24046 
24049  DistantLightKit & UnsetColor();
24050 
24053  DistantLightKit & UnsetCameraRelative();
24054 
24057  DistantLightKit & UnsetEverything();
24058 
24059 
24063  bool ShowPriority(int & out_priority) const;
24064 
24068  bool ShowDirection(HPS::Vector & out_vector) const;
24069 
24075  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
24076 
24080  bool ShowCameraRelative(bool & out_state) const;
24081 
24087  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24088 
24093  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24094 
24099  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24100 
24104  DistantLightKit & UnsetUserData(intptr_t in_index);
24105 
24110  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24111 
24115  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
24116 
24119  DistantLightKit & UnsetAllUserData();
24120 
24122  size_t ShowUserDataCount() const;
24123 
24127  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24128 
24133  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24134 
24139  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24140 };
24141 
24142 
24143 
24145 class HPS_API DistantLightKey : public GeometryKey
24146 {
24147 public:
24149  DistantLightKey();
24150 
24154  explicit DistantLightKey(Key const & in_that);
24155 
24158  DistantLightKey(DistantLightKey const & in_that);
24159 
24163  DistantLightKey & operator=(DistantLightKey const & in_that);
24164 
24168  DistantLightKey(DistantLightKey && in_that);
24169 
24173  DistantLightKey & operator=(DistantLightKey && in_that);
24174 
24175  ~DistantLightKey();
24176 
24177  HPS::Type ObjectType() const { return HPS::Type::DistantLightKey; };
24178 
24181  void Consume(DistantLightKit & in_kit);
24182 
24185  void Set(DistantLightKit const & in_kit);
24186 
24189  void Show(DistantLightKit & out_kit) const;
24190 
24195  DistantLightKey & SetDirection(HPS::Vector const & in_vector);
24196 
24200  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
24201 
24205  DistantLightKey & SetColorByIndex(float in_index);
24206 
24211  DistantLightKey & SetCameraRelative(bool in_state);
24212 
24213 
24216  DistantLightKey & UnsetColor();
24217 
24218 
24222  bool ShowDirection(HPS::Vector & out_vector) const;
24223 
24229  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
24230 
24234  bool ShowCameraRelative(bool & out_state) const;
24235 };
24236 
24237 
24238 
24239 
24241 class HPS_API CylinderKit : public Kit
24242 {
24243 public:
24245  CylinderKit();
24246 
24249  CylinderKit(CylinderKit const & in_kit);
24250 
24254  CylinderKit(CylinderKit && in_that);
24255 
24259  CylinderKit & operator=(CylinderKit && in_that);
24260 
24261  virtual ~CylinderKit();
24262 
24263  HPS::Type ObjectType() const { return HPS::Type::CylinderKit; };
24264 
24267  void Consume(CylinderKit & in_kit);
24268 
24271  void Set(CylinderKit const & in_kit);
24272 
24275  void Show(CylinderKit & out_kit) const;
24276 
24280  CylinderKit & operator=(CylinderKit const & in_kit);
24281 
24284  bool Empty() const;
24285 
24289  bool Equals(CylinderKit const & in_kit) const;
24290 
24294  bool operator==(CylinderKit const & in_kit) const;
24295 
24299  bool operator!=(CylinderKit const & in_kit) const;
24300 
24303  size_t GetPointCount() const;
24304 
24311  CylinderKit & SetPriority(int in_priority);
24312 
24315  CylinderKit & UnsetPriority();
24316 
24320  bool ShowPriority(int & out_priority) const;
24321 
24322 
24326  CylinderKit & SetPoints(PointArray const & in_points);
24327 
24332  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
24333 
24337  CylinderKit & SetRadii(FloatArray const & in_radii);
24338 
24343  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
24344 
24348  CylinderKit & SetCaps(Cylinder::Capping in_capping);
24349 
24350 
24353  CylinderKit & UnsetPoints();
24354 
24357  CylinderKit & UnsetRadii();
24358 
24361  CylinderKit & UnsetCaps();
24362 
24365  CylinderKit & UnsetEverything();
24366 
24367 
24371  bool ShowPoints(PointArray & out_points) const;
24372 
24378  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
24379 
24384  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
24385 
24391  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
24392 
24396  bool ShowRadii(FloatArray & out_radii) const;
24397 
24401  bool ShowCaps(Cylinder::Capping & out_caps) const;
24402 
24403 
24410  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24411 
24417  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24418 
24425  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24426 
24433  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24434 
24441  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24442 
24449  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24450 
24456  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24457 
24458 
24465  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24466 
24472  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24473 
24480  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24481 
24488  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24489 
24496  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24497 
24504  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24505 
24511  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24512 
24513 
24516  CylinderKit & UnsetVertexColors();
24517 
24522  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
24523 
24527  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
24528 
24529 
24533  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
24534 
24540  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
24541 
24546  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
24547 
24552  CylinderKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
24553 
24559  CylinderKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Cylinder::Component in_apply_to);
24560 
24570  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
24571 
24583  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;
24584 
24597  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
24598 
24604  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24605 
24610  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24611 
24616  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24617 
24621  CylinderKit & UnsetUserData(intptr_t in_index);
24622 
24627  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24628 
24632  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
24633 
24636  CylinderKit & UnsetAllUserData();
24637 
24639  size_t ShowUserDataCount() const;
24640 
24644  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24645 
24650  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24651 
24656  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24657 };
24658 
24659 
24660 
24662 class HPS_API CylinderKey : public GeometryKey
24663 {
24664 public:
24666  CylinderKey();
24667 
24671  explicit CylinderKey(Key const & in_that);
24672 
24675  CylinderKey(CylinderKey const & in_that);
24676 
24680  CylinderKey & operator=(CylinderKey const & in_that);
24681 
24685  CylinderKey(CylinderKey && in_that);
24686 
24690  CylinderKey & operator=(CylinderKey && in_that);
24691 
24692  ~CylinderKey();
24693 
24694  HPS::Type ObjectType() const { return HPS::Type::CylinderKey; };
24695 
24698  void Consume(CylinderKit & in_kit);
24699 
24702  void Set(CylinderKit const & in_kit);
24703 
24704 
24710  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
24711 
24716  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
24717 
24722  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
24723 
24729  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
24730 
24736  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
24737 
24738 
24744  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
24745 
24750  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
24751 
24756  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
24757 
24763  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
24764 
24770  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
24771 
24772 
24775  void Show(CylinderKit & out_kit) const;
24776 
24779  size_t GetPointCount() const;
24780 
24784  bool ShowPoints(PointArray & out_points) const;
24785 
24791  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
24792 
24797  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
24798 
24804  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
24805 
24809  bool ShowRadii(FloatArray & out_radii) const;
24810 
24814  bool ShowCaps(Cylinder::Capping & out_caps) const;
24815 
24816 
24823  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24824 
24831  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24832 
24839  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24840 
24841 
24848  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24849 
24856  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24857 
24864  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24865 
24872  CylinderKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24873 
24879  CylinderKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24880 
24887  CylinderKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24888 
24894  CylinderKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24895 
24902  CylinderKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24903 
24909  CylinderKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24910 
24917  CylinderKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24918 
24924  CylinderKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
24925 
24928  CylinderKey & UnsetVertexColors();
24929 
24934  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
24935 
24939  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
24940 
24946  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
24947 
24952  CylinderKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
24953 
24957  CylinderKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
24958 
24964  CylinderKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Cylinder::Component in_apply_to);
24965 
24971  CylinderKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
24972 
24982  bool ShowVertexColors(Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
24983 
24995  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;
24996 
25009  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
25010 };
25011 
25012 
25013 
25014 
25016 class HPS_API SphereKit : public Kit
25017 {
25018 public:
25020  SphereKit();
25021 
25024  SphereKit(SphereKit const & in_kit);
25025 
25029  SphereKit(SphereKit && in_that);
25030 
25034  SphereKit & operator=(SphereKit && in_that);
25035 
25036  virtual ~SphereKit();
25037 
25038  HPS::Type ObjectType() const { return HPS::Type::SphereKit; };
25039 
25042  void Consume(SphereKit & in_kit);
25043 
25046  void Set(SphereKit const & in_kit);
25047 
25050  void Show(SphereKit & out_kit) const;
25051 
25055  SphereKit & operator=(SphereKit const & in_kit);
25056 
25059  bool Empty() const;
25060 
25064  bool Equals(SphereKit const & in_kit) const;
25065 
25069  bool operator==(SphereKit const & in_kit) const;
25070 
25074  bool operator!=(SphereKit const & in_kit) const;
25075 
25082  SphereKit & SetPriority(int in_priority);
25083 
25086  SphereKit & UnsetPriority();
25087 
25091  bool ShowPriority(int & out_priority) const;
25092 
25096  SphereKit & SetCenter(Point const & in_center);
25097 
25101  SphereKit & SetRadius(float in_radius);
25102 
25107  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
25108 
25109 
25112  SphereKit & UnsetCenter();
25113 
25116  SphereKit & UnsetRadius();
25117 
25120  SphereKit & UnsetBasis();
25121 
25124  SphereKit & UnsetEverything();
25125 
25126 
25130  bool ShowCenter(Point & out_center) const;
25131 
25135  bool ShowRadius(float & out_radius) const;
25136 
25141  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
25142 
25148  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25149 
25154  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25155 
25160  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25161 
25165  SphereKit & UnsetUserData(intptr_t in_index);
25166 
25171  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25172 
25176  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
25177 
25180  SphereKit & UnsetAllUserData();
25181 
25183  size_t ShowUserDataCount() const;
25184 
25188  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25189 
25194  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25195 
25200  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25201 };
25202 
25204 class HPS_API SphereKey : public GeometryKey
25205 {
25206 public:
25208  SphereKey();
25209 
25213  explicit SphereKey(Key const & in_that);
25214 
25217  SphereKey(SphereKey const & in_that);
25218 
25222  SphereKey & operator=(SphereKey const & in_that);
25223 
25227  SphereKey(SphereKey && in_that);
25228 
25232  SphereKey & operator=(SphereKey && in_that);
25233 
25234  ~SphereKey();
25235 
25236  HPS::Type ObjectType() const {return HPS::Type::SphereKey;};
25237 
25240  void Consume(SphereKit & in_kit);
25241 
25244  void Set(SphereKit const & in_kit);
25245 
25248  void Show(SphereKit & out_kit) const;
25249 
25250 
25254  SphereKey & SetCenter(Point const & in_center);
25255 
25259  SphereKey & SetRadius(float in_radius);
25260 
25265  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
25266 
25267 
25271  bool ShowCenter(Point & out_center) const;
25272 
25276  bool ShowRadius(float & out_radius) const;
25277 
25282  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
25283 };
25284 
25285 
25286 
25287 
25289 class HPS_API CircleKit : public Kit
25290 {
25291 public:
25293  CircleKit();
25294 
25297  CircleKit(CircleKit const & in_kit);
25298 
25302  CircleKit(CircleKit && in_that);
25303 
25307  CircleKit & operator=(CircleKit && in_that);
25308 
25309  virtual ~CircleKit();
25310 
25311  HPS::Type ObjectType() const { return HPS::Type::CircleKit; };
25312 
25315  void Consume(CircleKit & in_kit);
25316 
25319  void Set(CircleKit const & in_kit);
25320 
25323  void Show(CircleKit & out_kit) const;
25324 
25328  CircleKit & operator=(CircleKit const & in_kit);
25329 
25332  bool Empty() const;
25333 
25337  bool Equals(CircleKit const & in_kit) const;
25338 
25342  bool operator==(CircleKit const & in_kit) const;
25343 
25347  bool operator!=(CircleKit const & in_kit) const;
25348 
25355  CircleKit & SetPriority(int const in_priority);
25356 
25359  CircleKit & UnsetPriority();
25360 
25364  bool ShowPriority(int & out_priority) const;
25365 
25366 
25367 
25371  CircleKit & SetCenter(Point const & in_center);
25372 
25376  CircleKit & SetRadius(float in_radius);
25377 
25381  CircleKit & SetNormal(Vector const & in_normal);
25382 
25383 
25386  CircleKit & UnsetCenter();
25387 
25390  CircleKit & UnsetRadius();
25391 
25394  CircleKit & UnsetNormal();
25395 
25398  CircleKit & UnsetEverything();
25399 
25400 
25404  bool ShowCenter(Point & out_center) const;
25405 
25409  bool ShowRadius(float & out_radius) const;
25410 
25414  bool ShowNormal(Vector & out_normal) const;
25415 
25421  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25422 
25427  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25428 
25433  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25434 
25438  CircleKit & UnsetUserData(intptr_t in_index);
25439 
25444  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25445 
25449  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
25450 
25453  CircleKit & UnsetAllUserData();
25454 
25456  size_t ShowUserDataCount() const;
25457 
25461  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25462 
25467  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25468 
25473  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25474 };
25475 
25476 
25479 class HPS_API CircleKey : public GeometryKey
25480 {
25481 public:
25483  CircleKey();
25484 
25488  explicit CircleKey(Key const & in_that);
25489 
25492  CircleKey(CircleKey const & in_that);
25493 
25497  CircleKey & operator=(CircleKey const & in_that);
25498 
25502  CircleKey(CircleKey && in_that);
25503 
25507  CircleKey & operator=(CircleKey && in_that);
25508 
25509  ~CircleKey();
25510 
25511  HPS::Type ObjectType() const { return HPS::Type::CircleKey; };
25512 
25513 
25516  void Consume(CircleKit & in_kit);
25517 
25520  void Set(CircleKit const & in_kit);
25521 
25524  void Show(CircleKit & out_kit) const;
25525 
25526 
25530  CircleKey & SetCenter(Point const & in_center);
25531 
25535  CircleKey & SetRadius(float in_radius);
25536 
25540  CircleKey & SetNormal(Vector const & in_normal);
25541 
25542 
25546  bool ShowCenter(Point & out_center) const;
25547 
25551  bool ShowRadius(float & out_radius) const;
25552 
25556  bool ShowNormal(Vector & out_normal) const;
25557 };
25558 
25559 
25560 
25561 
25563 class HPS_API CircularArcKit : public Kit
25564 {
25565 public:
25567  CircularArcKit();
25568 
25571  CircularArcKit(CircularArcKit const & in_kit);
25572 
25576  CircularArcKit(CircularArcKit && in_that);
25577 
25581  CircularArcKit & operator=(CircularArcKit && in_that);
25582 
25583  virtual ~CircularArcKit();
25584 
25585  HPS::Type ObjectType() const { return HPS::Type::CircularArcKit; };
25586 
25589  void Consume(CircularArcKit & in_kit);
25590 
25593  void Set(CircularArcKit const & in_kit);
25594 
25597  void Show(CircularArcKit & out_kit) const;
25598 
25602  CircularArcKit & operator=(CircularArcKit const & in_kit);
25603 
25606  bool Empty() const;
25607 
25611  bool Equals(CircularArcKit const & in_kit) const;
25612 
25616  bool operator==(CircularArcKit const & in_kit) const;
25617 
25621  bool operator!=(CircularArcKit const & in_kit) const;
25622 
25629  CircularArcKit & SetPriority(int in_priority);
25630 
25633  CircularArcKit & UnsetPriority();
25634 
25638  bool ShowPriority(int & out_priority) const;
25639 
25640 
25644  CircularArcKit & SetStart(Point const & in_start);
25645 
25649  CircularArcKit & SetMiddle(Point const & in_middle);
25650 
25654  CircularArcKit & SetEnd(Point const & in_end);
25655 
25656 
25659  CircularArcKit & UnsetStart();
25660 
25663  CircularArcKit & UnsetMiddle();
25664 
25667  CircularArcKit & UnsetEnd();
25668 
25671  CircularArcKit & UnsetEverything();
25672 
25673 
25677  bool ShowStart(Point & out_start) const;
25678 
25682  bool ShowMiddle(Point & out_middle) const;
25683 
25687  bool ShowEnd(Point & out_end) const;
25688 
25694  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25695 
25700  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25701 
25706  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25707 
25711  CircularArcKit & UnsetUserData(intptr_t in_index);
25712 
25717  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25718 
25722  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
25723 
25726  CircularArcKit & UnsetAllUserData();
25727 
25729  size_t ShowUserDataCount() const;
25730 
25734  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25735 
25740  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25741 
25746  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25747 };
25748 
25751 class HPS_API CircularArcKey : public GeometryKey
25752 {
25753 public:
25755  CircularArcKey();
25756 
25760  explicit CircularArcKey(Key const & in_that);
25761 
25764  CircularArcKey(CircularArcKey const & in_that);
25765 
25769  CircularArcKey & operator=(CircularArcKey const & in_that);
25770 
25774  CircularArcKey(CircularArcKey && in_that);
25775 
25779  CircularArcKey & operator=(CircularArcKey && in_that);
25780 
25781  ~CircularArcKey();
25782 
25783  HPS::Type ObjectType() const { return HPS::Type::CircularArcKey; };
25784 
25785 
25788  void Consume(CircularArcKit & in_kit);
25789 
25792  void Set(CircularArcKit const & in_kit);
25793 
25796  void Show(CircularArcKit & out_kit) const;
25797 
25798 
25802  CircularArcKey & SetStart(Point const & in_start);
25803 
25807  CircularArcKey & SetMiddle(Point const & in_middle);
25808 
25812  CircularArcKey & SetEnd(Point const & in_end);
25813 
25814 
25818  bool ShowStart(Point & out_start) const;
25819 
25823  bool ShowMiddle(Point & out_middle) const;
25824 
25828  bool ShowEnd(Point & out_end) const;
25829 };
25830 
25831 
25832 
25834 class HPS_API CircularWedgeKit : public Kit
25835 {
25836 public:
25838  CircularWedgeKit();
25839 
25842  CircularWedgeKit(CircularWedgeKit const & in_kit);
25843 
25847  CircularWedgeKit(CircularWedgeKit && in_that);
25848 
25852  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
25853 
25854  virtual ~CircularWedgeKit();
25855 
25856  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKit; };
25857 
25860  void Consume(CircularWedgeKit & in_kit);
25861 
25864  void Set(CircularWedgeKit const & in_kit);
25865 
25868  void Show(CircularWedgeKit & out_kit) const;
25869 
25873  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
25874 
25877  bool Empty() const;
25878 
25882  bool Equals(CircularWedgeKit const & in_kit) const;
25883 
25887  bool operator==(CircularWedgeKit const & in_kit) const;
25888 
25892  bool operator!=(CircularWedgeKit const & in_kit) const;
25893 
25894 
25901  CircularWedgeKit & SetPriority(int in_priority);
25902 
25905  CircularWedgeKit & UnsetPriority();
25906 
25910  bool ShowPriority(int & out_priority) const;
25911 
25912 
25916  CircularWedgeKit & SetStart(Point const & in_start);
25917 
25921  CircularWedgeKit & SetMiddle(Point const & in_middle);
25922 
25926  CircularWedgeKit & SetEnd(Point const & in_end);
25927 
25928 
25931  CircularWedgeKit & UnsetStart();
25932 
25935  CircularWedgeKit & UnsetMiddle();
25936 
25939  CircularWedgeKit & UnsetEnd();
25940 
25943  CircularWedgeKit & UnsetEverything();
25944 
25945 
25949  bool ShowStart(Point & out_start) const;
25950 
25954  bool ShowMiddle(Point & out_middle) const;
25955 
25959  bool ShowEnd(Point & out_end) const;
25960 
25966  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25967 
25972  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25973 
25978  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25979 
25983  CircularWedgeKit & UnsetUserData(intptr_t in_index);
25984 
25989  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25990 
25994  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
25995 
25998  CircularWedgeKit & UnsetAllUserData();
25999 
26001  size_t ShowUserDataCount() const;
26002 
26006  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26007 
26012  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26013 
26018  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26019 };
26020 
26021 
26025 class HPS_API CircularWedgeKey : public GeometryKey
26026 {
26027 public:
26029  CircularWedgeKey();
26030 
26034  explicit CircularWedgeKey(Key const & in_that);
26035 
26038  CircularWedgeKey(CircularWedgeKey const & in_that);
26039 
26043  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
26044 
26048  CircularWedgeKey(CircularWedgeKey && in_that);
26049 
26053  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
26054 
26055  ~CircularWedgeKey();
26056 
26057  HPS::Type ObjectType() const { return HPS::Type::CircularWedgeKey; };
26058 
26059 
26062  void Consume(CircularWedgeKit & in_kit);
26063 
26066  void Set(CircularWedgeKit const & in_kit);
26067 
26070  void Show(CircularWedgeKit & out_kit) const;
26071 
26072 
26076  CircularWedgeKey & SetStart(Point const & in_start);
26077 
26081  CircularWedgeKey & SetMiddle(Point const & in_middle);
26082 
26086  CircularWedgeKey & SetEnd(Point const & in_end);
26087 
26088 
26092  bool ShowStart(Point & out_start) const;
26093 
26097  bool ShowMiddle(Point & out_middle) const;
26098 
26102  bool ShowEnd(Point & out_end) const;
26103 };
26104 
26105 
26106 
26108 class HPS_API CuttingSectionKit : public Kit
26109 {
26110 public:
26113 
26116  CuttingSectionKit(CuttingSectionKit const & in_kit);
26117 
26122 
26126  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
26127 
26128  virtual ~CuttingSectionKit();
26129 
26130  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKit; };
26131 
26134  void Consume(CuttingSectionKit & in_kit);
26135 
26138  void Set(CuttingSectionKit const & in_kit);
26139 
26142  void Show(CuttingSectionKit & out_kit) const;
26143 
26147  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
26148 
26151  bool Empty() const;
26152 
26156  bool Equals(CuttingSectionKit const & in_kit) const;
26157 
26161  bool operator==(CuttingSectionKit const & in_kit) const;
26162 
26166  bool operator!=(CuttingSectionKit const & in_kit) const;
26167 
26174  CuttingSectionKit & SetPriority(int in_priority);
26175 
26178  CuttingSectionKit & UnsetPriority();
26179 
26183  bool ShowPriority(int & out_priority) const;
26184 
26185 
26189  CuttingSectionKit & SetPlanes(Plane const & in_plane);
26190 
26194  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
26195 
26200  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
26201 
26207  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
26208 
26209 
26212  CuttingSectionKit & UnsetPlanes();
26213 
26216  CuttingSectionKit & UnsetVisualization();
26217 
26220  CuttingSectionKit & UnsetEverything();
26221 
26222 
26225  size_t GetPlaneCount() const;
26226 
26230  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
26231 
26237  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
26238 
26239 
26246  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
26247 
26253  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
26254 
26261  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
26262 
26269  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
26270 
26278  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
26279 
26285  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26286 
26291  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26292 
26297  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26298 
26302  CuttingSectionKit & UnsetUserData(intptr_t in_index);
26303 
26308  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26309 
26313  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
26314 
26317  CuttingSectionKit & UnsetAllUserData();
26318 
26320  size_t ShowUserDataCount() const;
26321 
26325  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26326 
26331  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26332 
26337  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26338 };
26339 
26340 
26342 class HPS_API CuttingSectionKey : public GeometryKey
26343 {
26344 public:
26347 
26351  explicit CuttingSectionKey(Key const & in_that);
26352 
26355  CuttingSectionKey(CuttingSectionKey const & in_that);
26356 
26360  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
26361 
26366 
26370  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
26371 
26372  ~CuttingSectionKey();
26373 
26374  HPS::Type ObjectType() const { return HPS::Type::CuttingSectionKey; };
26375 
26376 
26379  void Consume(CuttingSectionKit & in_kit);
26380 
26383  void Set(CuttingSectionKit const & in_kit);
26384 
26387  void Show(CuttingSectionKit & out_kit) const;
26388 
26389 
26393  CuttingSectionKey & SetPlanes(Plane const & in_plane);
26394 
26398  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
26399 
26404  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
26405 
26411  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
26412 
26413 
26416  size_t GetPlaneCount() const;
26417 
26421  bool ShowPlanes(HPS::PlaneArray & out_planes) const;
26422 
26428  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
26429 
26430 
26437  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
26438 
26444  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
26445 
26452  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
26453 
26460  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
26461 
26467  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
26468 };
26469 
26470 
26471 
26473 class HPS_API InfiniteLineKit : public Kit
26474 {
26475 public:
26477  InfiniteLineKit();
26478 
26481  InfiniteLineKit(InfiniteLineKit const & in_kit);
26482 
26486  InfiniteLineKit(InfiniteLineKit && in_that);
26487 
26491  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
26492 
26493  virtual ~InfiniteLineKit();
26494 
26495  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKit; };
26496 
26499  void Consume(InfiniteLineKit & in_kit);
26500 
26503  void Set(InfiniteLineKit const & in_kit);
26504 
26507  void Show(InfiniteLineKit & out_kit) const;
26508 
26512  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
26513 
26516  bool Empty() const;
26517 
26521  bool Equals(InfiniteLineKit const & in_kit) const;
26522 
26526  bool operator==(InfiniteLineKit const & in_kit) const;
26527 
26531  bool operator!=(InfiniteLineKit const & in_kit) const;
26532 
26539  InfiniteLineKit & SetPriority(int in_priority);
26540 
26543  InfiniteLineKit & UnsetPriority();
26544 
26548  bool ShowPriority(int & out_priority) const;
26549 
26550 
26554  InfiniteLineKit & SetFirst(Point const & in_first);
26555 
26559  InfiniteLineKit & SetSecond(Point const & in_second);
26560 
26564  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
26565 
26566 
26569  InfiniteLineKit & UnsetFirst();
26570 
26573  InfiniteLineKit & UnsetSecond();
26574 
26577  InfiniteLineKit & UnsetType();
26578 
26581  InfiniteLineKit & UnsetEverything();
26582 
26583 
26587  bool ShowFirst(Point & out_first) const;
26588 
26592  bool ShowSecond(Point & out_second) const;
26593 
26597  bool ShowType(InfiniteLine::Type & out_type) const;
26598 
26604  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26605 
26610  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26611 
26616  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26617 
26621  InfiniteLineKit & UnsetUserData(intptr_t in_index);
26622 
26627  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26628 
26632  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
26633 
26636  InfiniteLineKit & UnsetAllUserData();
26637 
26639  size_t ShowUserDataCount() const;
26640 
26644  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26645 
26650  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26651 
26656  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26657 };
26658 
26659 
26661 class HPS_API InfiniteLineKey : public GeometryKey
26662 {
26663 public:
26665  InfiniteLineKey();
26666 
26670  explicit InfiniteLineKey(Key const & in_that);
26671 
26674  InfiniteLineKey(InfiniteLineKey const & in_that);
26675 
26679  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
26680 
26684  InfiniteLineKey(InfiniteLineKey && in_that);
26685 
26689  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
26690 
26691  ~InfiniteLineKey();
26692 
26693  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineKey; };
26694 
26697  void Consume(InfiniteLineKit & in_kit);
26698 
26701  void Set(InfiniteLineKit const & in_kit);
26702 
26705  void Show(InfiniteLineKit & out_kit) const;
26706 
26707 
26711  InfiniteLineKey & SetFirst(Point const & in_first);
26712 
26716  InfiniteLineKey & SetSecond(Point const & in_second);
26717 
26721  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
26722 
26723 
26727  bool ShowFirst(Point & out_first) const;
26728 
26732  bool ShowSecond(Point & out_second) const;
26733 
26737  bool ShowType(InfiniteLine::Type & out_type) const;
26738 };
26739 
26740 
26741 
26745 class HPS_API SpotlightKit : public Kit
26746 {
26747 public:
26749  SpotlightKit();
26750 
26753  SpotlightKit(SpotlightKit const & in_kit);
26754 
26758  SpotlightKit(SpotlightKit && in_that);
26759 
26763  SpotlightKit & operator=(SpotlightKit && in_that);
26764 
26765  virtual ~SpotlightKit();
26766 
26767  HPS::Type ObjectType() const { return HPS::Type::SpotlightKit; };
26768 
26772  static SpotlightKit GetDefault();
26773 
26776  void Consume(SpotlightKit & in_kit);
26777 
26780  void Set(SpotlightKit const & in_kit);
26781 
26784  void Show(SpotlightKit & out_kit) const;
26785 
26789  SpotlightKit & operator=(SpotlightKit const & in_kit);
26790 
26793  bool Empty() const;
26794 
26798  bool Equals(SpotlightKit const & in_kit) const;
26799 
26803  bool operator==(SpotlightKit const & in_kit) const;
26804 
26808  bool operator!=(SpotlightKit const & in_kit) const;
26809 
26810 
26817  SpotlightKit & SetPriority(int in_priority);
26818 
26824  SpotlightKit & SetPosition(HPS::Point const & in_position);
26825 
26831  SpotlightKit & SetTarget(HPS::Point const & in_target);
26832 
26836  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
26837 
26841  SpotlightKit & SetColorByIndex(float in_index);
26842 
26849 
26856 
26862  SpotlightKit & SetConcentration(float in_concentration);
26863 
26869  SpotlightKit & SetCameraRelative(bool in_state);
26870 
26871 
26874  SpotlightKit & UnsetPriority();
26875 
26878  SpotlightKit & UnsetPosition();
26879 
26882  SpotlightKit & UnsetTarget();
26883 
26886  SpotlightKit & UnsetColor();
26887 
26890  SpotlightKit & UnsetOuterCone();
26891 
26894  SpotlightKit & UnsetInnerCone();
26895 
26898  SpotlightKit & UnsetConcentration();
26899 
26902  SpotlightKit & UnsetCameraRelative();
26903 
26906  SpotlightKit & UnsetEverything();
26907 
26908 
26912  bool ShowPriority(int & out_priority) const;
26913 
26917  bool ShowPosition(HPS::Point & out_position) const;
26918 
26922  bool ShowTarget(HPS::Point & out_target) const;
26923 
26929  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
26930 
26935  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
26936 
26941  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
26942 
26946  bool ShowConcentration(float & out_concentration) const;
26947 
26951  bool ShowCameraRelative(bool & out_state) const;
26952 
26958  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26959 
26964  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26965 
26970  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26971 
26975  SpotlightKit & UnsetUserData(intptr_t in_index);
26976 
26981  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26982 
26986  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
26987 
26990  SpotlightKit & UnsetAllUserData();
26991 
26993  size_t ShowUserDataCount() const;
26994 
26998  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26999 
27004  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27005 
27010  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27011 };
27012 
27013 
27015 class HPS_API SpotlightKey : public GeometryKey
27016 {
27017 public:
27019  SpotlightKey();
27020 
27024  explicit SpotlightKey(Key const & in_that);
27025 
27028  SpotlightKey(SpotlightKey const & in_that);
27029 
27033  SpotlightKey & operator=(SpotlightKey const & in_that);
27034 
27038  SpotlightKey(SpotlightKey && in_that);
27039 
27043  SpotlightKey & operator=(SpotlightKey && in_that);
27044 
27045  ~SpotlightKey();
27046 
27047  HPS::Type ObjectType() const { return HPS::Type::SpotlightKey; };
27048 
27051  void Consume(SpotlightKit & in_kit);
27052 
27055  void Set(SpotlightKit const & in_kit);
27056 
27059  void Show(SpotlightKit & out_kit) const;
27060 
27061 
27067  SpotlightKey & SetPosition(HPS::Point const & in_position);
27068 
27074  SpotlightKey & SetTarget(HPS::Point const & in_target);
27075 
27079  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
27080 
27084  SpotlightKey & SetColorByIndex(float in_index);
27085 
27092 
27099 
27105  SpotlightKey & SetConcentration(float in_concentration);
27106 
27112  SpotlightKey & SetCameraRelative(bool in_state);
27113 
27114 
27117  SpotlightKey & UnsetColor();
27118 
27119 
27123  bool ShowPosition(HPS::Point & out_position) const;
27124 
27128  bool ShowTarget(HPS::Point & out_target) const;
27129 
27135  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27136 
27141  bool ShowOuterCone(float & out_size, HPS::Spotlight::OuterConeUnits & out_units) const;
27142 
27147  bool ShowInnerCone(float & out_size, HPS::Spotlight::InnerConeUnits & out_units) const;
27148 
27152  bool ShowConcentration(float & out_concentration) const;
27153 
27157  bool ShowCameraRelative(bool & out_state) const;
27158 };
27159 
27160 
27161 
27163 class HPS_API NURBSCurveKit : public Kit
27164 {
27165 public:
27167  NURBSCurveKit();
27168 
27171  NURBSCurveKit(NURBSCurveKit const & in_kit);
27172 
27176  NURBSCurveKit(NURBSCurveKit && in_that);
27177 
27181  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
27182 
27183  virtual ~NURBSCurveKit();
27184 
27185  HPS::Type ObjectType() const { return HPS::Type::NURBSCurveKit; };
27186 
27189  void Consume(NURBSCurveKit & in_kit);
27190 
27193  void Set(NURBSCurveKit const & in_kit);
27194 
27197  void Show(NURBSCurveKit & out_kit) const;
27198 
27202  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
27203 
27206  bool Empty() const;
27207 
27211  bool Equals(NURBSCurveKit const & in_kit) const;
27212 
27216  bool operator==(NURBSCurveKit const & in_kit) const;
27217 
27221  bool operator!=(NURBSCurveKit const & in_kit) const;
27222 
27225  size_t GetPointCount() const;
27226 
27233  NURBSCurveKit & SetPriority(int in_priority);
27234 
27237  NURBSCurveKit & UnsetPriority();
27238 
27242  bool ShowPriority(int & out_priority) const;
27243 
27247  NURBSCurveKit & SetDegree(size_t in_degree);
27248 
27252  NURBSCurveKit & SetPoints(PointArray const & in_points);
27253 
27258  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
27259 
27263  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
27264 
27269  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
27270 
27274  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
27275 
27280  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
27281 
27286  NURBSCurveKit & SetParameters(float in_start, float in_end);
27287 
27288 
27291  NURBSCurveKit & UnsetDegree();
27292 
27295  NURBSCurveKit & UnsetPoints();
27296 
27299  NURBSCurveKit & UnsetWeights();
27300 
27303  NURBSCurveKit & UnsetKnots();
27304 
27307  NURBSCurveKit & UnsetParameters();
27308 
27311  NURBSCurveKit & UnsetEverything();
27312 
27313 
27317  bool ShowDegree(size_t & out_degree) const;
27318 
27322  bool ShowPoints(PointArray & out_points) const;
27323 
27329  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
27330 
27335  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
27336 
27342  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
27343 
27347  bool ShowWeights(FloatArray & out_weights) const;
27348 
27352  bool ShowKnots(FloatArray & out_knots) const;
27353 
27358  bool ShowParameters(float & out_start, float & out_end) const;
27359 
27360 
27367  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
27368 
27374  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
27375 
27382  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
27383 
27390  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
27391 
27398  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
27399 
27400 
27408  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
27409 
27416  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
27417 
27425  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
27426 
27433  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
27434 
27441  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
27442 
27443 
27449  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
27450 
27455  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
27456 
27462  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
27463 
27470  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
27471 
27478  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
27479 
27485  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27486 
27491  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27492 
27497  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27498 
27502  NURBSCurveKit & UnsetUserData(intptr_t in_index);
27503 
27508  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27509 
27513  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
27514 
27517  NURBSCurveKit & UnsetAllUserData();
27518 
27520  size_t ShowUserDataCount() const;
27521 
27525  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27526 
27531  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27532 
27537  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27538 };
27539 
27540 
27542 class HPS_API NURBSCurveKey : public GeometryKey
27543 {
27544 public:
27546  NURBSCurveKey();
27547 
27551  explicit NURBSCurveKey(Key const & in_that);
27552 
27555  NURBSCurveKey(NURBSCurveKey const & in_that);
27556 
27560  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
27561 
27565  NURBSCurveKey(NURBSCurveKey && in_that);
27566 
27570  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
27571 
27572  ~NURBSCurveKey();
27573 
27574  HPS::Type ObjectType() const {return HPS::Type::NURBSCurveKey;};
27575 
27578  void Consume(NURBSCurveKit & in_kit);
27579 
27582  void Set(NURBSCurveKit const & in_kit);
27583 
27586  void Show(NURBSCurveKit & out_kit) const;
27587 
27590  size_t GetPointCount() const;
27591 
27596  NURBSCurveKey & SetParameters(float in_start, float in_end);
27597 
27601  bool ShowDegree(size_t & out_degree) const;
27602 
27606  bool ShowPoints(PointArray & out_points) const;
27607 
27613  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
27614 
27619  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
27620 
27626  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
27627 
27631  bool ShowWeights(FloatArray & out_weights) const;
27632 
27636  bool ShowKnots(FloatArray & out_knots) const;
27637 
27642  bool ShowParameters(float & out_start, float & out_end) const;
27643 
27644 
27652  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
27653 
27660  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
27661 
27662 
27671  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
27672 
27680  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
27681 
27682 
27690  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
27691 
27698  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
27699 };
27700 
27701 
27702 
27704 class HPS_API NURBSSurfaceKit : public Kit
27705 {
27706 public:
27708  NURBSSurfaceKit();
27709 
27712  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
27713 
27717  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
27718 
27722  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
27723 
27724  virtual ~NURBSSurfaceKit();
27725 
27726  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKit; };
27727 
27730  void Consume(NURBSSurfaceKit & in_kit);
27731 
27734  void Set(NURBSSurfaceKit const & in_kit);
27735 
27738  void Show(NURBSSurfaceKit & out_kit) const;
27739 
27743  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
27744 
27747  bool Empty() const;
27748 
27752  bool Equals(NURBSSurfaceKit const & in_kit) const;
27753 
27757  bool operator==(NURBSSurfaceKit const & in_kit) const;
27758 
27762  bool operator!=(NURBSSurfaceKit const & in_kit) const;
27763 
27766  size_t GetPointCount() const;
27767 
27774  NURBSSurfaceKit & SetPriority(int in_priority);
27775 
27778  NURBSSurfaceKit & UnsetPriority();
27779 
27783  bool ShowPriority(int & out_priority) const;
27784 
27788  NURBSSurfaceKit & SetUDegree(size_t in_degree);
27789 
27793  NURBSSurfaceKit & SetVDegree(size_t in_degree);
27794 
27798  NURBSSurfaceKit & SetUCount(size_t in_count);
27799 
27803  NURBSSurfaceKit & SetVCount(size_t in_count);
27804 
27808  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
27809 
27814  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
27815 
27820  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
27821 
27827  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
27828 
27833  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
27834 
27840  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
27841 
27846  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
27847 
27853  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
27854 
27858  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
27859 
27864  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
27865 
27869  NURBSSurfaceKit & SetTrim(TrimKit const & in_trim);
27870 
27871 
27874  NURBSSurfaceKit & UnsetUDegree();
27875 
27878  NURBSSurfaceKit & UnsetVDegree();
27879 
27882  NURBSSurfaceKit & UnsetUCount();
27883 
27886  NURBSSurfaceKit & UnsetVCount();
27887 
27890  NURBSSurfaceKit & UnsetPoints();
27891 
27894  NURBSSurfaceKit & UnsetWeights();
27895 
27898  NURBSSurfaceKit & UnsetUKnots();
27899 
27902  NURBSSurfaceKit & UnsetVKnots();
27903 
27906  NURBSSurfaceKit & UnsetTrims();
27907 
27910  NURBSSurfaceKit & UnsetEverything();
27911 
27912 
27916  bool ShowUDegree(size_t & out_degree) const;
27917 
27921  bool ShowVDegree(size_t & out_degree) const;
27922 
27926  bool ShowUCount(size_t & out_count) const;
27927 
27931  bool ShowVCount(size_t & out_count) const;
27932 
27936  bool ShowPoints(PointArray & out_points) const;
27937 
27943  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
27944 
27949  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
27950 
27956  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
27957 
27961  bool ShowWeights(FloatArray & out_weights) const;
27962 
27966  bool ShowUKnots(FloatArray & out_knots) const;
27967 
27971  bool ShowVKnots(FloatArray & out_knots) const;
27972 
27976  bool ShowTrims(TrimKitArray & out_trims) const;
27977 
27978 
27985  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
27986 
27992  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
27993 
28000  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
28001 
28008  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
28009 
28016  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
28017 
28018 
28026  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
28027 
28034  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
28035 
28043  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
28044 
28051  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
28052 
28059  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
28060 
28061 
28068  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
28069 
28075  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
28076 
28083  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
28084 
28091  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28092 
28099  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28100 
28101 
28108  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
28109 
28115  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
28116 
28123  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
28124 
28131  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28132 
28139  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28140 
28146  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28147 
28152  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28153 
28158  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28159 
28163  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
28164 
28169  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28170 
28174  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
28175 
28178  NURBSSurfaceKit & UnsetAllUserData();
28179 
28181  size_t ShowUserDataCount() const;
28182 
28186  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28187 
28192  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28193 
28198  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28199 };
28200 
28201 
28203 class HPS_API NURBSSurfaceKey : public GeometryKey
28204 {
28205 public:
28207  NURBSSurfaceKey();
28208 
28212  explicit NURBSSurfaceKey(Key const & in_that);
28213 
28216  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
28217 
28221  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
28222 
28226  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
28227 
28231  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
28232 
28233  ~NURBSSurfaceKey();
28234 
28235  HPS::Type ObjectType() const { return HPS::Type::NURBSSurfaceKey; };
28236 
28239  void Consume(NURBSSurfaceKit & in_kit);
28240 
28243  void Set(NURBSSurfaceKit const & in_kit);
28244 
28247  void Show(NURBSSurfaceKit & out_kit) const;
28248 
28251  size_t GetPointCount() const;
28252 
28257  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
28258 
28262  NURBSSurfaceKey & SetTrim(TrimKit const & in_trim);
28263 
28267  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
28268 
28269 
28272  NURBSSurfaceKey & UnsetTrims();
28273 
28274 
28278  bool ShowUDegree(size_t & out_degree) const;
28279 
28283  bool ShowVDegree(size_t & out_degree) const;
28284 
28288  bool ShowUCount(size_t & out_count) const;
28289 
28293  bool ShowVCount(size_t & out_count) const;
28294 
28298  bool ShowPoints(PointArray & out_points) const;
28299 
28305  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
28306 
28311  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
28312 
28318  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
28319 
28323  bool ShowWeights(FloatArray & out_weights) const;
28324 
28328  bool ShowUKnots(FloatArray & out_knots) const;
28329 
28333  bool ShowVKnots(FloatArray & out_knots) const;
28334 
28338  bool ShowTrims(TrimKitArray & out_trims) const;
28339 
28340 
28348  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
28349 
28356  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
28357 
28358 
28367  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
28368 
28376  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
28377 
28378 
28386  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28387 
28394  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28395 
28396 
28404  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
28405 
28412  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
28413 };
28414 
28415 
28416 
28418 class HPS_API TrimElement : public Object
28419 {
28420 public:
28422  TrimElement();
28423 
28426  TrimElement(TrimElement const & in_that);
28427 
28431  TrimElement(LineKit const & in_line);
28432 
28436  TrimElement(NURBSCurveKit const & in_curve);
28437 
28441  TrimElement(TrimElement && in_that);
28442 
28446  TrimElement & operator=(TrimElement && in_that);
28447 
28448  ~TrimElement();
28449 
28450  HPS::Type ObjectType() const { return HPS::Type::TrimElement; };
28451 
28454  void Set(TrimElement const & in_that);
28455 
28459  TrimElement & operator=(TrimElement const & in_that);
28460 
28464  bool Equals(TrimElement const & in_that) const;
28465 
28469  bool operator==(TrimElement const & in_that) const;
28470 
28474  bool operator!=(TrimElement const & in_that) const;
28475 
28476 
28480  void SetCurve(LineKit const & in_line);
28481 
28485  void SetCurve(NURBSCurveKit const & in_curve);
28486 
28492  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
28493 };
28494 
28495 
28496 
28498 class HPS_API TrimKit : public Kit
28499 {
28500 public:
28502  TrimKit();
28503 
28506  TrimKit(TrimKit const & in_kit);
28507 
28511  TrimKit(TrimKit && in_that);
28512 
28516  TrimKit & operator=(TrimKit && in_that);
28517 
28518  virtual ~TrimKit();
28519 
28520  HPS::Type ObjectType() const { return HPS::Type::TrimKit; };
28521 
28524  void Set(TrimKit const & in_kit);
28525 
28528  void Show(TrimKit & out_kit) const;
28529 
28533  TrimKit & operator=(TrimKit const & in_kit);
28534 
28537  bool Empty() const;
28538 
28542  bool Equals(TrimKit const & in_kit) const;
28543 
28547  bool operator==(TrimKit const & in_kit) const;
28548 
28552  bool operator!=(TrimKit const & in_kit) const;
28553 
28554 
28559  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
28560 
28564  TrimKit & SetShape(TrimElementArray const & in_shape);
28565 
28569  TrimKit & SetShape(TrimElement const & in_shape);
28570 
28571 
28575  TrimKit & SetOperation(Trim::Operation in_operation);
28576 
28577 
28580  TrimKit & UnsetShape();
28581 
28584  TrimKit & UnsetOperation();
28585 
28588  TrimKit & UnsetEverything();
28589 
28590 
28594  bool ShowShape(TrimElementArray & out_shape) const;
28595 
28599  bool ShowOperation(Trim::Operation & out_operation) const;
28600 };
28601 
28602 
28603 
28605 class HPS_API EllipseKit : public Kit
28606 {
28607 public:
28609  EllipseKit();
28610 
28613  EllipseKit(EllipseKit const & in_kit);
28614 
28618  EllipseKit(EllipseKit && in_that);
28619 
28623  EllipseKit & operator=(EllipseKit && in_that);
28624 
28625  virtual ~EllipseKit();
28626 
28627  HPS::Type ObjectType() const { return HPS::Type::EllipseKit; };
28628 
28631  void Consume(EllipseKit & in_kit);
28632 
28635  void Set(EllipseKit const & in_kit);
28636 
28639  void Show(EllipseKit & out_kit) const;
28640 
28644  EllipseKit & operator=(EllipseKit const & in_kit);
28645 
28648  bool Empty() const;
28649 
28653  bool Equals(EllipseKit const & in_kit) const;
28654 
28658  bool operator==(EllipseKit const & in_kit) const;
28659 
28663  bool operator!=(EllipseKit const & in_kit) const;
28664 
28671  EllipseKit & SetPriority(int in_priority);
28672 
28675  EllipseKit & UnsetPriority();
28676 
28680  bool ShowPriority(int & out_priority) const;
28681 
28682 
28686  EllipseKit & SetCenter(Point const & in_center);
28687 
28691  EllipseKit & SetMajor(Point const & in_major);
28692 
28696  EllipseKit & SetMinor(Point const & in_minor);
28697 
28698 
28701  EllipseKit & UnsetCenter();
28702 
28705  EllipseKit & UnsetMajor();
28706 
28709  EllipseKit & UnsetMinor();
28710 
28713  EllipseKit & UnsetEverything();
28714 
28715 
28719  bool ShowCenter(Point & out_center) const;
28720 
28724  bool ShowMajor(Point & out_major) const;
28725 
28729  bool ShowMinor(Point & out_minor) const;
28730 
28736  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
28737 
28742  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
28743 
28748  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
28749 
28753  EllipseKit & UnsetUserData(intptr_t in_index);
28754 
28759  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
28760 
28764  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
28765 
28768  EllipseKit & UnsetAllUserData();
28769 
28771  size_t ShowUserDataCount() const;
28772 
28776  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
28777 
28782  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
28783 
28788  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
28789 };
28790 
28791 
28792 
28794 class HPS_API EllipseKey : public GeometryKey
28795 {
28796 public:
28798  EllipseKey();
28799 
28803  explicit EllipseKey(Key const & in_that);
28804 
28807  EllipseKey(EllipseKey const & in_that);
28808 
28812  EllipseKey & operator=(EllipseKey const & other);
28813 
28817  EllipseKey(EllipseKey && in_that);
28818 
28822  EllipseKey & operator=(EllipseKey && in_that);
28823 
28824  ~EllipseKey();
28825 
28826  HPS::Type ObjectType() const { return HPS::Type::EllipseKey; };
28827 
28830  void Consume(EllipseKit & in_kit);
28831 
28834  void Set(EllipseKit const & in_kit);
28835 
28838  void Show(EllipseKit & out_kit) const;
28839 
28840 
28844  EllipseKey & SetCenter(Point const & in_center);
28845 
28849  EllipseKey & SetMajor(Point const & in_major);
28850 
28854  EllipseKey & SetMinor(Point const & in_minor);
28855 
28856 
28860  bool ShowCenter(Point & out_center) const;
28861 
28865  bool ShowMajor(Point & out_major) const;
28866 
28870  bool ShowMinor(Point & out_minor) const;
28871 };
28872 
28873 
28874 
28876 class HPS_API EllipticalArcKit : public Kit
28877 {
28878 public:
28880  EllipticalArcKit();
28881 
28884  EllipticalArcKit(EllipticalArcKit const & in_kit);
28885 
28889  EllipticalArcKit(EllipticalArcKit && in_that);
28890 
28894  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
28895 
28896  virtual ~EllipticalArcKit();
28897 
28898  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKit; };
28899 
28902  void Consume(EllipticalArcKit & in_kit);
28903 
28906  void Set(EllipticalArcKit const & in_kit);
28907 
28910  void Show(EllipticalArcKit & out_kit) const;
28911 
28915  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
28916 
28919  bool Empty() const;
28920 
28924  bool Equals(EllipticalArcKit const & in_kit) const;
28925 
28929  bool operator==(EllipticalArcKit const & in_kit) const;
28930 
28934  bool operator!=(EllipticalArcKit const & in_kit) const;
28935 
28942  EllipticalArcKit & SetPriority(int in_priority);
28943 
28946  EllipticalArcKit & UnsetPriority();
28947 
28951  bool ShowPriority(int & out_priority) const;
28952 
28953 
28957  EllipticalArcKit & SetCenter(Point const & in_center);
28958 
28962  EllipticalArcKit & SetMajor(Point const & in_major);
28963 
28967  EllipticalArcKit & SetMinor(Point const & in_minor);
28968 
28976  EllipticalArcKit & SetStart(float in_start);
28977 
28985  EllipticalArcKit & SetEnd(float in_end);
28986 
28987 
28990  EllipticalArcKit & UnsetCenter();
28991 
28994  EllipticalArcKit & UnsetMajor();
28995 
28998  EllipticalArcKit & UnsetMinor();
28999 
29002  EllipticalArcKit & UnsetStart();
29003 
29006  EllipticalArcKit & UnsetEnd();
29007 
29010  EllipticalArcKit & UnsetEverything();
29011 
29012 
29016  bool ShowCenter(Point & out_center) const;
29017 
29021  bool ShowMajor(Point & out_major) const;
29022 
29026  bool ShowMinor(Point & out_minor) const;
29027 
29031  bool ShowStart(float & out_start) const;
29032 
29036  bool ShowEnd(float & out_end) const;
29037 
29043  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29044 
29049  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29050 
29055  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29056 
29060  EllipticalArcKit & UnsetUserData(intptr_t in_index);
29061 
29066  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29067 
29071  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
29072 
29075  EllipticalArcKit & UnsetAllUserData();
29076 
29078  size_t ShowUserDataCount() const;
29079 
29083  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29084 
29089  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29090 
29095  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29096 };
29097 
29098 
29100 class HPS_API EllipticalArcKey : public GeometryKey
29101 {
29102 public:
29104  EllipticalArcKey();
29105 
29109  explicit EllipticalArcKey(Key const & in_that);
29110 
29113  EllipticalArcKey(EllipticalArcKey const & in_that);
29114 
29118  EllipticalArcKey & operator=(EllipticalArcKey const & other);
29119 
29123  EllipticalArcKey(EllipticalArcKey && in_that);
29124 
29128  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
29129 
29130  ~EllipticalArcKey();
29131 
29132  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcKey; };
29133 
29134 
29137  void Consume(EllipticalArcKit & in_kit);
29138 
29141  void Set(EllipticalArcKit const & in_kit);
29142 
29145  void Show(EllipticalArcKit & out_kit) const;
29146 
29147 
29151  EllipticalArcKey & SetCenter(Point const & in_center);
29152 
29156  EllipticalArcKey & SetMajor(Point const & in_major);
29157 
29161  EllipticalArcKey & SetMinor(Point const & in_minor);
29162 
29170  EllipticalArcKey & SetStart(float in_start);
29171 
29179  EllipticalArcKey & SetEnd(float in_end);
29180 
29181 
29185  bool ShowCenter(Point & out_center) const;
29186 
29190  bool ShowMajor(Point & out_major) const;
29191 
29195  bool ShowMinor(Point & out_minor) const;
29196 
29200  bool ShowStart(float & out_start) const;
29201 
29205  bool ShowEnd(float & out_end) const;
29206 };
29207 
29208 
29209 
29211 class HPS_API TextKit : public Kit
29212 {
29213 public:
29215  TextKit();
29216 
29219  TextKit(TextKit const & in_kit);
29220 
29224  TextKit(TextKit && in_that);
29225 
29229  TextKit & operator=(TextKit && in_that);
29230 
29231  virtual ~TextKit();
29232 
29233  HPS::Type ObjectType() const { return HPS::Type::TextKit; };
29234 
29237  void Consume(TextKit & in_kit);
29238 
29241  void Set(TextKit const & in_kit);
29242 
29245  void Show(TextKit & out_kit) const;
29246 
29250  TextKit & operator=(TextKit const & in_kit);
29251 
29254  bool Empty() const;
29255 
29259  bool Equals(TextKit const & in_kit) const;
29260 
29264  bool operator==(TextKit const & in_kit) const;
29265 
29269  bool operator!=(TextKit const & in_kit) const;
29270 
29277  TextKit & SetPriority(int in_priority);
29278 
29281  TextKit & UnsetPriority();
29282 
29286  bool ShowPriority(int & out_priority) const;
29287 
29291  TextKit & SetPosition(Point const & in_position);
29292 
29296  TextKit & SetText(char const * in_string);
29297 
29301  TextKit & SetColor(RGBAColor const & in_rgba_color);
29302 
29306  TextKit & SetColorByIndex(float in_index);
29307 
29311  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
29312 
29318  TextKit & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
29319 
29323  TextKit & SetBold(bool in_state);
29324 
29328  TextKit & SetItalic(bool in_state);
29329 
29333  TextKit & SetOverline(bool in_state);
29334 
29338  TextKit & SetStrikethrough(bool in_state);
29339 
29343  TextKit & SetUnderline(bool in_state);
29344 
29349  TextKit & SetSlant(float in_angle);
29350 
29354  TextKit & SetLineSpacing(float in_multiplier);
29355 
29361  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
29362 
29366  TextKit & SetRotation(float in_angle);
29367 
29373  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
29374 
29379  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
29380 
29387  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
29388 
29394  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
29395 
29404  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
29405 
29413  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
29414 
29419  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
29420 
29426  TextKit & SetFont(char const * in_name);
29427 
29431  TextKit & SetTransform(Text::Transform in_trans);
29432 
29436  TextKit & SetRenderer(Text::Renderer in_rend);
29437 
29441  TextKit & SetPreference(Text::Preference in_pref);
29442 
29449  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
29450 
29454  TextKit & SetPath(Vector const & in_path);
29455 
29461  TextKit & SetSpacing(float in_multiplier);
29462 
29467  TextKit & SetBackground(bool in_state, char const * in_name);
29468 
29473  TextKit & SetBackground(char const * in_name);
29474 
29478  TextKit & SetBackground(bool in_state);
29479 
29484  TextKit & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
29485 
29491  TextKit & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
29492 
29499  TextKit & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
29500 
29505  TextKit & SetBackgroundStyle(char const * in_name);
29506 
29511  TextKit & SetLeaderLine(Point const & in_position, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
29512 
29517  TextKit & SetLeaderLines(PointArray const & in_positions, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
29518 
29524  TextKit & SetLeaderLines(size_t in_count, Point const in_positions [], Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
29525 
29528  TextKit & UnsetPosition();
29529 
29532  TextKit & UnsetText();
29533 
29536  TextKit & UnsetColor();
29537 
29540  TextKit & UnsetModellingMatrix();
29541 
29544  TextKit & UnsetAlignment();
29545 
29548  TextKit & UnsetBold();
29549 
29552  TextKit & UnsetItalic();
29553 
29556  TextKit & UnsetOverline();
29557 
29560  TextKit & UnsetStrikethrough();
29561 
29564  TextKit & UnsetUnderline();
29565 
29568  TextKit & UnsetSlant();
29569 
29572  TextKit & UnsetLineSpacing();
29573 
29576  TextKit & UnsetRotation();
29577 
29580  TextKit & UnsetExtraSpace();
29581 
29584  TextKit & UnsetGreeking();
29585 
29588  TextKit & UnsetSizeTolerance();
29589 
29592  TextKit & UnsetSize();
29593 
29596  TextKit & UnsetFont();
29597 
29600  TextKit & UnsetTransform();
29601 
29604  TextKit & UnsetRenderer();
29605 
29608  TextKit & UnsetPreference();
29609 
29612  TextKit & UnsetPath();
29613 
29616  TextKit & UnsetSpacing();
29617 
29620  TextKit & UnsetBackground();
29621 
29624  TextKit & UnsetBackgroundMargins();
29625 
29628  TextKit & UnsetBackgroundStyle();
29629 
29632  TextKit & UnsetLeaderLines();
29633 
29636  TextKit & UnsetEverything();
29637 
29638 
29642  bool ShowPosition(Point & out_position) const;
29643 
29647  bool ShowText(UTF8 & out_string) const;
29648 
29654  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
29655 
29659  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
29660 
29666  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
29667 
29671  bool ShowBold(bool & out_state) const;
29672 
29676  bool ShowItalic(bool & out_state) const;
29677 
29681  bool ShowOverline(bool & out_state) const;
29682 
29686  bool ShowStrikethrough(bool & out_state) const;
29687 
29691  bool ShowUnderline(bool & out_state) const;
29692 
29696  bool ShowSlant(float & out_angle) const;
29697 
29701  bool ShowLineSpacing(float & out_multiplier) const;
29702 
29707  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
29708 
29714  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
29715 
29722  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
29723 
29729  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
29730 
29735  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
29736 
29740  bool ShowFont(UTF8 & out_name) const;
29741 
29745  bool ShowTransform(Text::Transform & out_trans) const;
29746 
29750  bool ShowRenderer(Text::Renderer & out_renderer) const;
29751 
29758  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
29759 
29763  bool ShowPath(Vector & out_path) const;
29764 
29768  bool ShowSpacing(float & out_multiplier) const;
29769 
29774  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
29775 
29780  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
29781 
29785  bool ShowBackgroundStyle(UTF8 & out_name) const;
29786 
29791  bool ShowLeaderLines(PointArray & out_positions, Text::LeaderLineSpace & out_space) const;
29792 
29800  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
29801 
29808  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
29809 
29817  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
29818 
29827  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
29828 
29841  TextKit & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
29842 
29856  TextKit & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
29857 
29863  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29864 
29867  TextKit & UnsetRegion();
29868 
29873  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29874 
29879  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29880 
29884  TextKit & UnsetUserData(intptr_t in_index);
29885 
29890  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29891 
29895  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
29896 
29899  TextKit & UnsetAllUserData();
29900 
29902  size_t ShowUserDataCount() const;
29903 
29907  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29908 
29913  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29914 
29919  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29920 };
29921 
29922 
29924 class HPS_API TextKey : public GeometryKey
29925 {
29926 public:
29928  TextKey();
29929 
29933  explicit TextKey(Key const & in_that);
29934 
29937  TextKey(TextKey const & in_that);
29938 
29942  TextKey & operator=(TextKey const & other);
29943 
29947  TextKey(TextKey && in_that);
29948 
29952  TextKey & operator=(TextKey && in_that);
29953 
29954  ~TextKey();
29955 
29956  HPS::Type ObjectType() const {return HPS::Type::TextKey;};
29957 
29960  void Consume(TextKit & in_kit);
29961 
29964  void Set(TextKit const & in_kit);
29965 
29968  void Show(TextKit & out_kit) const;
29969 
29972  TextKey & SetTextAttribute(TextAttributeKit const & in_kit);
29973 
29977  bool ShowTextAttribute(TextAttributeKit & out_kit) const;
29978 
29982  TextKey & SetPosition(Point const & in_position);
29983 
29987  TextKey & SetText(char const * in_string);
29988 
29992  TextKey & SetColor(RGBAColor const & in_rgba_color);
29993 
29997  TextKey & SetColorByIndex(float in_index);
29998 
30002  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
30003 
30009  TextKey & SetAlignment(Text::Alignment in_alignment, Text::ReferenceFrame in_reference_frame = Text::ReferenceFrame::WorldAligned, Text::Justification in_justification = Text::Justification::Left);
30010 
30014  TextKey & SetBold(bool in_state);
30015 
30019  TextKey & SetItalic(bool in_state);
30020 
30024  TextKey & SetOverline(bool in_state);
30025 
30029  TextKey & SetStrikethrough(bool in_state);
30030 
30034  TextKey & SetUnderline(bool in_state);
30035 
30040  TextKey & SetSlant(float in_angle);
30041 
30046  TextKey & SetLineSpacing(float in_multiplier);
30047 
30053  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
30054 
30058  TextKey & SetRotation(float in_angle);
30059 
30065  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
30066 
30071  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
30072 
30079  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
30080 
30086  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
30087 
30096  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
30097 
30105  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
30106 
30111  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
30112 
30118  TextKey & SetFont(char const * in_name);
30119 
30123  TextKey & SetTransform(Text::Transform in_transform);
30124 
30128  TextKey & SetRenderer(Text::Renderer in_renderer);
30129 
30133  TextKey & SetPreference(Text::Preference in_preference);
30134 
30142  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
30143 
30148  TextKey & SetPath(Vector const & in_path);
30149 
30155  TextKey & SetSpacing(float in_multiplier);
30156 
30169  TextKey & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
30170 
30184  TextKey & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
30185 
30190  TextKey & SetBackground(bool in_state, char const * in_name);
30191 
30196  TextKey & SetBackground(char const * in_name);
30197 
30201  TextKey & SetBackground(bool in_state);
30202 
30207  TextKey & SetBackgroundMargins(float in_size, Text::MarginUnits in_units = Text::MarginUnits::Percent);
30208 
30214  TextKey & SetBackgroundMargins(FloatArray const & in_sizes, TextMarginUnitsArray const & in_units);
30215 
30222  TextKey & SetBackgroundMargins(size_t in_count, float const in_sizes [], HPS::Text::MarginUnits const in_units []);
30223 
30228  TextKey & SetBackgroundStyle(char const * in_name);
30229 
30234  TextKey & SetLeaderLine(Point const & in_position, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30235 
30240  TextKey & SetLeaderLines(PointArray const & in_positions, Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30241 
30247  TextKey & SetLeaderLines(size_t in_count, Point const in_positions [], Text::LeaderLineSpace in_space = Text::LeaderLineSpace::Object);
30248 
30249 
30252  TextKey & UnsetColor();
30253 
30256  TextKey & UnsetModellingMatrix();
30257 
30260  TextKey & UnsetAlignment();
30261 
30264  TextKey & UnsetBold();
30265 
30268  TextKey & UnsetItalic();
30269 
30272  TextKey & UnsetOverline();
30273 
30276  TextKey & UnsetStrikethrough();
30277 
30280  TextKey & UnsetUnderline();
30281 
30284  TextKey & UnsetSlant();
30285 
30288  TextKey & UnsetLineSpacing();
30289 
30292  TextKey & UnsetRotation();
30293 
30296  TextKey & UnsetExtraSpace();
30297 
30300  TextKey & UnsetGreeking();
30301 
30304  TextKey & UnsetSizeTolerance();
30305 
30308  TextKey & UnsetSize();
30309 
30312  TextKey & UnsetFont();
30313 
30316  TextKey & UnsetTransform();
30317 
30320  TextKey & UnsetRenderer();
30321 
30324  TextKey & UnsetPreference();
30325 
30328  TextKey & UnsetPath();
30329 
30332  TextKey & UnsetSpacing();
30333 
30336  TextKey & UnsetRegion();
30337 
30340  TextKey & UnsetBackground();
30341 
30344  TextKey & UnsetBackgroundMargins();
30345 
30348  TextKey & UnsetBackgroundStyle();
30349 
30352  TextKey & UnsetLeaderLines();
30353 
30356  TextKey & UnsetEverything();
30357 
30358 
30362  bool ShowPosition(Point & out_position) const;
30363 
30367  bool ShowText(UTF8 & out_string) const;
30368 
30374  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
30375 
30379  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
30380 
30386  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
30387 
30391  bool ShowBold(bool & out_state) const;
30392 
30396  bool ShowItalic(bool & out_state) const;
30397 
30401  bool ShowOverline(bool & out_state) const;
30402 
30406  bool ShowStrikethrough(bool & out_state) const;
30407 
30411  bool ShowUnderline(bool & out_state) const;
30412 
30416  bool ShowSlant(float & out_angle) const;
30417 
30421  bool ShowLineSpacing(float & out_multiplier) const;
30422 
30427  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
30428 
30434  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
30435 
30442  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
30443 
30449  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
30450 
30455  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
30456 
30460  bool ShowFont(UTF8 & out_name) const;
30461 
30465  bool ShowTransform(Text::Transform & out_trans) const;
30466 
30470  bool ShowRenderer(Text::Renderer & out_renderer) const;
30471 
30478  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
30479 
30483  bool ShowPath(Vector & out_path) const;
30484 
30488  bool ShowSpacing(float & out_multiplier) const;
30489 
30498  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
30499 
30504  bool ShowBackground(bool & out_state, UTF8 & out_name) const;
30505 
30510  bool ShowBackgroundMargins(FloatArray & out_size, TextMarginUnitsArray & out_units) const;
30511 
30515  bool ShowBackgroundStyle(UTF8 & out_name) const;
30516 
30521  bool ShowLeaderLines(PointArray & out_positions, Text::LeaderLineSpace & out_space) const;
30522 
30530  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
30531 
30538  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
30539 
30547  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
30548 };
30549 
30550 
30552 class HPS_API ShellOptimizationOptionsKit : public Kit
30553 {
30554 public:
30557 
30561 
30566 
30567  virtual ~ShellOptimizationOptionsKit();
30568 
30569  HPS::Type ObjectType() const { return HPS::Type::ShellOptimizationOptionsKit; };
30570 
30573  void Consume(ShellOptimizationOptionsKit & in_kit);
30574 
30577  void Set(ShellOptimizationOptionsKit const & in_kit);
30578 
30581  void Show(ShellOptimizationOptionsKit & out_kit) const;
30582 
30586  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
30587 
30592 
30595  bool Empty() const;
30596 
30600  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
30601 
30605  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
30606 
30610  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
30611 
30615  static ShellOptimizationOptionsKit GetDefault();
30616 
30617 
30621  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
30622 
30627  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
30628 
30633  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
30634 
30639  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
30640 
30641 
30644  ShellOptimizationOptionsKit & UnsetNormalTolerance();
30645 
30648  ShellOptimizationOptionsKit & UnsetTolerance();
30649 
30652  ShellOptimizationOptionsKit & UnsetOrphanElimination();
30653 
30656  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
30657 
30660  ShellOptimizationOptionsKit & UnsetEverything();
30661 
30662 
30666  bool ShowNormalTolerance(float & out_normal_tolerance) const;
30667 
30672  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
30673 
30677  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
30678 
30683  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
30684 };
30685 
30686 
30690 class HPS_API ShellRelationOptionsKit : public Kit
30691 {
30692 public:
30695 
30699 
30704 
30708  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
30709 
30710  virtual ~ShellRelationOptionsKit();
30711 
30712  HPS::Type ObjectType() const { return HPS::Type::ShellRelationOptionsKit; };
30713 
30717  static ShellRelationOptionsKit GetDefault();
30718 
30721  void Consume(ShellRelationOptionsKit & in_kit);
30722 
30725  void Set(ShellRelationOptionsKit const & in_kit);
30726 
30729  void Show(ShellRelationOptionsKit & out_kit) const;
30730 
30734  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
30735 
30738  bool Empty() const;
30739 
30743  bool Equals(ShellRelationOptionsKit const & in_kit) const;
30744 
30748  bool operator==(ShellRelationOptionsKit const & in_kit) const;
30749 
30753  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
30754 
30755 
30759  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
30760 
30764  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
30765 
30770  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
30771 
30775  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
30776 
30777 
30780  ShellRelationOptionsKit & UnsetTolerance();
30781 
30784  ShellRelationOptionsKit & UnsetTest();
30785 
30788  ShellRelationOptionsKit & UnsetTreeContext();
30789 
30792  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
30793 
30796  ShellRelationOptionsKit & UnsetEverything();
30797 
30798 
30802  bool ShowTolerance(float & out_tolerance) const;
30803 
30807  bool ShowTest(Shell::RelationTest & out_test) const;
30808 
30812  bool ShowTreeContext(TreeContext & out_tree_context) const;
30813 
30817  bool ShowNearestFaceCalculation(bool & out_state) const;
30818 };
30819 
30821 class HPS_API ShellRelationResultsKit : public Kit
30822 {
30823 public:
30826 
30830 
30835 
30839  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
30840 
30841  virtual ~ShellRelationResultsKit();
30842 
30843  HPS::Type ObjectType() const { return HPS::Type::ShellRelationResultsKit; };
30844 
30847  void Consume(ShellRelationResultsKit & in_kit);
30848 
30851  void Set(ShellRelationResultsKit const & in_kit);
30852 
30855  void Show(ShellRelationResultsKit & out_kit) const;
30856 
30860  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
30861 
30864  bool Empty() const;
30865 
30869  bool Equals(ShellRelationResultsKit const & in_kit) const;
30870 
30874  bool operator==(ShellRelationResultsKit const & in_kit) const;
30875 
30879  bool operator!=(ShellRelationResultsKit const & in_kit) const;
30880 
30881 
30885  bool ShowRelations(ShellRelationArray & out_results) const;
30886 
30890  bool ShowNearestFaces(SizeTArray & out_faces) const;
30891 
30895  bool ShowDistances(FloatArray & out_distances) const;
30896 };
30897 
30898 
30900 class HPS_API ShellKit : public Kit
30901 {
30902 public:
30904  ShellKit();
30905 
30908  ShellKit(ShellKit const & in_kit);
30909 
30913  ShellKit(ShellKit && in_that);
30914 
30918  ShellKit & operator=(ShellKit && in_that);
30919 
30920  virtual ~ShellKit();
30921 
30922  HPS::Type ObjectType() const { return HPS::Type::ShellKit; };
30923 
30926  void Consume(ShellKit & in_kit);
30927 
30930  void Set(ShellKit const & in_kit);
30931 
30934  void Show(ShellKit & out_kit) const;
30935 
30938  size_t GetPointCount() const;
30939 
30942  size_t GetFaceCount() const;
30943 
30947  ShellKit & operator=(ShellKit const & in_kit);
30948 
30951  bool Empty() const;
30952 
30956  bool Equals(ShellKit const & in_kit) const;
30957 
30961  bool operator==(ShellKit const & in_kit) const;
30962 
30966  bool operator!=(ShellKit const & in_kit) const;
30967 
30974  ShellKit & SetPriority(int in_priority);
30975 
30978  ShellKit & UnsetPriority();
30979 
30983  bool ShowPriority(int & out_priority) const;
30984 
30985 
30986 
30990  ShellKit & SetPoints(PointArray const & in_points);
30991 
30996  ShellKit & SetPoints(size_t in_count, Point const in_points []);
30997 
31001  ShellKit & SetFacelist(IntArray const & in_facelist);
31002 
31007  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
31008 
31012  ShellKit & SetTristrips(IntArray const & in_tristrips);
31013 
31018  ShellKit & SetTristrips(size_t in_count, int const in_tristrips []);
31019 
31022  ShellKit & UnsetPoints();
31023 
31026  ShellKit & UnsetFacelist();
31027 
31030  ShellKit & UnsetTristrips();
31031 
31034  ShellKit & UnsetEverything();
31035 
31039  bool ShowPoints(PointArray & out_points) const;
31040 
31046  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
31047 
31052  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
31053 
31059  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
31060 
31064  bool ShowFacelist(IntArray & out_facelist) const;
31065 
31069  bool ShowTristrips(IntArray & out_tristrips) const;
31070 
31076  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
31077 
31084  ShellKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
31085 
31092  ShellKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
31093 
31099  ShellKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
31100 
31106  ShellKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
31107 
31113  ShellKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
31114 
31120  ShellKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
31121 
31128  ShellKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
31129 
31136  ShellKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
31137 
31143  ShellKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
31144 
31150  ShellKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
31151 
31158  ShellKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
31159 
31166  ShellKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
31167 
31175  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
31176 
31184  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
31185 
31193  ShellKit & UnsetEdgeColors();
31194 
31199  ShellKit & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
31200 
31206  ShellKit & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
31207 
31210  ShellKit & UnsetEdgeVisibilities();
31211 
31214  ShellKit & UnsetEdgeEverything();
31215 
31220  ShellKit & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
31221 
31227  ShellKit & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
31228 
31229 
31238  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
31239 
31246  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
31247 
31253  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
31254 
31261  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
31262 
31269  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
31270 
31277  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
31278 
31285  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
31286 
31292  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
31293 
31294 
31301  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
31302 
31308  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
31309 
31316  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
31317 
31324  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
31325 
31332  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
31333 
31340  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
31341 
31347  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
31348 
31349 
31356  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
31357 
31363  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
31364 
31371  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
31372 
31379  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
31380 
31387  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
31388 
31395  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
31396 
31402  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
31403 
31404 
31410  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31411 
31416  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31417 
31423  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31424 
31430  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31431 
31436  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31437 
31443  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31444 
31449  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31450 
31451 
31458  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31459 
31466  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31467 
31476  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);
31477 
31485  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31486 
31487 
31493  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31494 
31499  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31500 
31506  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31507 
31513  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31514 
31519  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31520 
31526  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31527 
31532  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31533 
31534 
31537  ShellKit & UnsetMaterialMapping();
31538 
31539 
31542  ShellKit & UnsetVertexColors();
31543 
31548  ShellKit & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
31549 
31554  ShellKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
31555 
31561  ShellKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Shell::Component in_apply_to);
31562 
31567  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31568 
31572  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31573 
31574 
31578  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
31579 
31585  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
31586 
31591  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
31592 
31593 
31596  ShellKit & UnsetVertexNormals();
31597 
31602  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31603 
31607  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31608 
31609 
31612  ShellKit & UnsetVertexParameters();
31613 
31618  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31619 
31623  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31624 
31625 
31628  ShellKit & UnsetVertexVisibilities();
31629 
31634  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31635 
31639  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31640 
31641 
31644  ShellKit & UnsetVertexEverything();
31645 
31646 
31650  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31651 
31652 
31664  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
31665  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31666 
31680  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
31681  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31682 
31697  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
31698  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31699 
31706  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
31707 
31716  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31717 
31726  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31727 
31728 
31736  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
31737 
31745  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31746 
31756  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31757 
31767  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31768 
31778  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31779 
31789  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31790 
31791 
31798  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
31799 
31808  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31809 
31818  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31819 
31820 
31821 
31827  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31828 
31833  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31834 
31840  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31841 
31847  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31848 
31853  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31854 
31860  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31861 
31866  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31867 
31868 
31874  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31875 
31880  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31881 
31887  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31888 
31894  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31895 
31900  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31901 
31907  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31908 
31913  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31914 
31915 
31921  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31922 
31927  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31928 
31934  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31935 
31941  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
31942 
31947  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
31948 
31954  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
31955 
31960  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
31961 
31962 
31968  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31969 
31974  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31975 
31981  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31982 
31988  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31989 
31994  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31995 
32001  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32002 
32007  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32008 
32009 
32012  ShellKit & UnsetFaceColors();
32013 
32018  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32019 
32023  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
32024 
32025 
32028  ShellKit & UnsetFaceNormals();
32029 
32034  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32035 
32039  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
32040 
32041 
32044  ShellKit & UnsetFaceVisibilities();
32045 
32050  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32051 
32055  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
32056 
32061  ShellKit & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
32062 
32067  ShellKit & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
32068 
32071  ShellKit & UnsetFaceEverything();
32072 
32080  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32081 
32091  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32092 
32103  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32104 
32105 
32112  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
32113 
32122  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32123 
32132  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32133 
32140  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
32141 
32150  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32151 
32160  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32161 
32162 
32169  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
32170 
32176  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
32177 
32183  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
32184 
32190  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
32191 
32197  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
32198 
32199 
32206  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
32207 
32213  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
32214 
32220  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
32221 
32230  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
32231 
32239  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
32240 
32243  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
32244 
32249  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
32250 
32255  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
32256 
32261  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
32262 
32268  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32269 
32274  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32275 
32280  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32281 
32285  ShellKit & UnsetUserData(intptr_t in_index);
32286 
32291  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32292 
32296  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
32297 
32300  ShellKit & UnsetAllUserData();
32301 
32303  size_t ShowUserDataCount() const;
32304 
32308  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32309 
32314  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32315 
32320  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32321 };
32322 
32323 
32324 
32326 class HPS_API ShellKey : public GeometryKey
32327 {
32328 public:
32330  ShellKey();
32331 
32336  explicit ShellKey(Key const & in_that);
32337 
32340  ShellKey(ShellKey const & in_that);
32341 
32345  ShellKey & operator=(ShellKey const & other);
32346 
32350  ShellKey(ShellKey && in_that);
32351 
32355  ShellKey & operator=(ShellKey && in_that);
32356 
32357  ~ShellKey();
32358 
32359  HPS::Type ObjectType() const { return HPS::Type::ShellKey; };
32360 
32363  void Consume(ShellKit & in_kit);
32364 
32367  void Set(ShellKit const & in_kit);
32368 
32371  void Show(ShellKit & out_kit) const;
32372 
32375  size_t GetPointCount() const;
32376 
32379  size_t GetFaceCount() const;
32380 
32381 
32385  ShellKey & SetPoints(PointArray const & in_points);
32386 
32391  ShellKey & SetPoints(size_t in_count, Point const in_points []);
32392 
32396  ShellKey & SetFacelist(IntArray const & in_facelist);
32397 
32402  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
32403 
32407  ShellKey & SetTristrips(IntArray const & in_tristrips);
32408 
32413  ShellKey & SetTristrips(size_t in_count, int const in_tristrips []);
32414 
32419  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
32420 
32423  ShellKey & UnsetPoints();
32424 
32427  ShellKey & UnsetFacelist();
32428 
32431  ShellKey & UnsetTristrips();
32432 
32435  ShellKey & UnsetMaterialMapping();
32436 
32439  ShellKey & UnsetEverything();
32440 
32444  bool ShowPoints(PointArray & out_points) const;
32445 
32451  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
32452 
32457  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
32458 
32464  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
32465 
32469  bool ShowFacelist(IntArray & out_facelist) const;
32470 
32474  bool ShowTristrips(IntArray & out_tristrips) const;
32475 
32480  bool ShowTristrips(IntArray & out_tristrips, IntArray & out_face_indices) const;
32481 
32485  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
32486 
32493  ShellKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
32494 
32501  ShellKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
32502 
32508  ShellKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
32509 
32515  ShellKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
32516 
32522  ShellKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
32523 
32529  ShellKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
32530 
32537  ShellKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
32538 
32545  ShellKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
32546 
32552  ShellKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
32553 
32559  ShellKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
32560 
32567  ShellKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
32568 
32575  ShellKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
32576 
32584  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
32585 
32593  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
32594 
32602  ShellKey & UnsetEdgeColors();
32603 
32608  ShellKey & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
32609 
32615  ShellKey & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
32616 
32619  ShellKey & UnsetEdgeVisibilities();
32620 
32623  ShellKey & UnsetEdgeEverything();
32624 
32629  ShellKey & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
32630 
32636  ShellKey & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
32637 
32638 
32647  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
32648 
32655  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32656 
32663  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32664 
32671  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32672 
32679  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32680 
32687  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32688 
32695  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32696 
32702  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
32703 
32704 
32711  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32712 
32719  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32720 
32727  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32728 
32735  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
32736 
32743  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
32744 
32751  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32752 
32758  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
32759 
32760 
32767  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
32768 
32775  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
32776 
32783  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32784 
32791  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
32792 
32799  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
32800 
32807  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32808 
32814  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
32815 
32816 
32822  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32823 
32829  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
32830 
32836  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32837 
32843  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
32844 
32849  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
32850 
32856  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
32857 
32862  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
32863 
32864 
32872  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
32873 
32880  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
32881 
32890  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);
32891 
32899  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
32900 
32901 
32907  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32908 
32914  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32915 
32921  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32922 
32928  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
32929 
32934  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
32935 
32941  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
32942 
32947  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
32948 
32953  ShellKey & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
32954 
32959  ShellKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
32960 
32966  ShellKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Shell::Component in_apply_to);
32967 
32970  ShellKey & UnsetVertexColors();
32971 
32976  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
32977 
32981  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
32982 
32983 
32987  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
32988 
32994  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
32995 
33000  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
33001 
33002 
33005  ShellKey & UnsetVertexNormals();
33006 
33011  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
33012 
33016  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
33017 
33018 
33021  ShellKey & UnsetVertexParameters();
33022 
33027  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
33028 
33032  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
33033 
33034 
33037  ShellKey & UnsetVertexVisibilities();
33038 
33043  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
33044 
33048  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
33049 
33050 
33053  ShellKey & UnsetVertexEverything();
33054 
33055 
33067  bool ShowVertexColors(Shell::Component in_apply_to, MaterialTypeArray & out_types,
33068  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33069 
33083  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to, MaterialTypeArray & out_types,
33084  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33085 
33100  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to, MaterialTypeArray & out_types,
33101  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
33102 
33103 
33110  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33111 
33120  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33121 
33130  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
33131 
33135  bool ShowNetVertexNormals(VectorArray & out_normals) const;
33136 
33142  bool ShowNetVertexNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
33143 
33151  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
33152 
33160  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33161 
33171  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
33172 
33182  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33183 
33193  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
33194 
33204  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
33205 
33206 
33213  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33214 
33223  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33224 
33233  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
33234 
33235 
33241  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
33242 
33248  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
33249 
33255  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
33256 
33262  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
33263 
33268  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
33269 
33275  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
33276 
33281  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
33282 
33283 
33289  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
33290 
33296  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
33297 
33303  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
33304 
33310  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
33311 
33316  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
33317 
33323  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
33324 
33329  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
33330 
33331 
33337  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
33338 
33344  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
33345 
33351  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
33352 
33358  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
33359 
33364  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
33365 
33371  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
33372 
33377  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
33378 
33379 
33385  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
33386 
33392  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
33393 
33399  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
33400 
33406  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
33407 
33412  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
33413 
33419  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
33420 
33425  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
33426 
33427 
33430  ShellKey & UnsetFaceColors();
33431 
33436  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
33437 
33441  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
33442 
33447  ShellKey & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
33448 
33453  ShellKey & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
33454 
33457  ShellKey & UnsetFaceNormals();
33458 
33463  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
33464 
33468  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
33469 
33470 
33473  ShellKey & UnsetFaceVisibilities();
33474 
33479  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
33480 
33484  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
33485 
33486 
33489  ShellKey & UnsetFaceEverything();
33490 
33498  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33499 
33509  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33510 
33521  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
33522 
33529  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
33530 
33539  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
33540 
33549  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
33550 
33551 
33557  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
33558 
33565  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
33566 
33567 
33574  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
33575 
33584  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
33585 
33594  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
33595 
33596 
33603  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
33604 
33610  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
33611 
33617  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
33618 
33624  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
33625 
33631  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
33632 
33633 
33640  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
33641 
33647  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
33648 
33654  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
33655 
33664  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
33665 
33673  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
33674 
33677  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
33678 
33683  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33684 
33689  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33690 
33695  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
33696 };
33697 
33698 
33699 
33701 class HPS_API MeshKit : public Kit
33702 {
33703 public:
33705  MeshKit();
33706 
33709  MeshKit(MeshKit const & in_kit);
33710 
33714  MeshKit(MeshKit && in_that);
33715 
33719  MeshKit & operator=(MeshKit && in_that);
33720 
33721  virtual ~MeshKit();
33722 
33723  HPS::Type ObjectType() const { return HPS::Type::MeshKit; };
33724 
33727  void Consume(MeshKit & in_kit);
33728 
33731  void Set(MeshKit const & in_kit);
33732 
33735  void Show(MeshKit & out_kit) const;
33736 
33740  MeshKit & operator=(MeshKit const & in_kit);
33741 
33744  bool Empty() const;
33745 
33749  bool Equals(MeshKit const & in_kit) const;
33750 
33754  bool operator==(MeshKit const & in_kit) const;
33755 
33759  bool operator!=(MeshKit const & in_kit) const;
33760 
33763  size_t GetPointCount() const;
33764 
33771  MeshKit & SetPriority(int in_priority);
33772 
33775  MeshKit & UnsetPriority();
33776 
33780  bool ShowPriority(int & out_priority) const;
33781 
33785  MeshKit & SetPoints(PointArray const & in_points);
33786 
33791  MeshKit & SetPoints(size_t in_count, Point const in_points []);
33792 
33798  MeshKit & SetPoints(size_t in_rows, size_t in_columns, HPS::PointArray const & in_points);
33799 
33806  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
33807 
33811  MeshKit & SetRows(size_t in_rows);
33812 
33816  MeshKit & SetColumns(size_t in_columns);
33817 
33820  MeshKit & UnsetPoints();
33821 
33824  MeshKit & UnsetRows();
33825 
33828  MeshKit & UnsetColumns();
33829 
33832  MeshKit & UnsetEverything();
33833 
33837  bool ShowPoints(PointArray & out_points) const;
33838 
33844  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
33845 
33850  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
33851 
33857  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
33858 
33864  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
33865 
33869  bool ShowRows(size_t & out_rows) const;
33870 
33874  bool ShowColumns(size_t & out_columns) const;
33875 
33881  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
33882 
33889  MeshKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
33890 
33897  MeshKit & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
33898 
33904  MeshKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
33905 
33911  MeshKit & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
33912 
33918  MeshKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
33919 
33925  MeshKit & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
33926 
33933  MeshKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
33934 
33941  MeshKit & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
33942 
33948  MeshKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
33949 
33955  MeshKit & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
33956 
33963  MeshKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
33964 
33971  MeshKit & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
33972 
33980  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
33981 
33989  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
33990 
33998  MeshKit & UnsetEdgeColors();
33999 
34004  MeshKit & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
34005 
34011  MeshKit & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
34012 
34015  MeshKit & UnsetEdgeVisibilities();
34016 
34019  MeshKit & UnsetEdgeEverything();
34020 
34025  MeshKit & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
34026 
34032  MeshKit & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
34033 
34034 
34043  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
34044 
34051  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
34052 
34058  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
34059 
34066  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
34067 
34074  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
34075 
34082  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
34083 
34090  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
34091 
34097  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
34098 
34099 
34106  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
34107 
34113  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
34114 
34121  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
34122 
34129  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
34130 
34137  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
34138 
34145  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
34146 
34152  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
34153 
34154 
34161  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
34162 
34168  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
34169 
34176  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
34177 
34184  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
34185 
34192  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
34193 
34200  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
34201 
34207  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
34208 
34209 
34215  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
34216 
34221  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
34222 
34228  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
34229 
34235  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
34236 
34241  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
34242 
34248  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
34249 
34254  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
34255 
34256 
34263  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
34264 
34271  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
34272 
34281  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);
34282 
34290  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
34291 
34292 
34298  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
34299 
34304  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
34305 
34311  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
34312 
34318  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
34319 
34324  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
34325 
34331  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
34332 
34337  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
34338 
34339 
34342  MeshKit & UnsetMaterialMapping();
34343 
34346  MeshKit & UnsetVertexColors();
34347 
34352  MeshKit & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
34353 
34358  MeshKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
34359 
34365  MeshKit & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Mesh::Component in_apply_to);
34366 
34371  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
34372 
34376  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
34377 
34378 
34382  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
34383 
34389  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
34390 
34395  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
34396 
34397 
34400  MeshKit & UnsetVertexNormals();
34401 
34406  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
34407 
34411  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
34412 
34413 
34416  MeshKit & UnsetVertexParameters();
34417 
34422  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
34423 
34427  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
34428 
34429 
34432  MeshKit & UnsetVertexVisibilities();
34433 
34438  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
34439 
34443  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
34444 
34445 
34448  MeshKit & UnsetVertexEverything();
34449 
34450 
34454  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
34455 
34467  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
34468  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34469 
34483  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
34484  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34485 
34500  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
34501  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
34502 
34503 
34510  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
34511 
34520  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
34521 
34530  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
34531 
34539  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
34540 
34548  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34549 
34559  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
34560 
34570  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34571 
34581  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
34582 
34592  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
34593 
34600  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
34601 
34610  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
34611 
34620  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
34621 
34622 
34628  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
34629 
34634  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
34635 
34641  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
34642 
34648  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
34649 
34654  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
34655 
34661  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
34662 
34667  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
34668 
34669 
34675  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
34676 
34681  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
34682 
34688  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
34689 
34695  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
34696 
34701  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
34702 
34708  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
34709 
34714  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
34715 
34716 
34722  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
34723 
34728  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
34729 
34735  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
34736 
34742  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
34743 
34748  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
34749 
34755  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
34756 
34761  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
34762 
34763 
34769  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
34770 
34775  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
34776 
34782  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
34783 
34789  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
34790 
34795  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
34796 
34802  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
34803 
34808  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
34809 
34810 
34813  MeshKit & UnsetFaceColors();
34814 
34819  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
34820 
34824  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
34825 
34830  MeshKit & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
34831 
34836  MeshKit & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
34837 
34840  MeshKit & UnsetFaceNormals();
34841 
34846  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
34847 
34851  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
34852 
34853 
34856  MeshKit & UnsetFaceVisibilities();
34857 
34862  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
34863 
34867  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
34868 
34869 
34872  MeshKit & UnsetFaceEverything();
34873 
34881  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34882 
34892  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34893 
34904  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
34905 
34906 
34913  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
34914 
34923  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
34924 
34933  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
34934 
34941  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
34942 
34951  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
34952 
34961  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
34962 
34968  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
34969 
34974  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
34975 
34980  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
34981 
34985  MeshKit & UnsetUserData(intptr_t in_index);
34986 
34991  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
34992 
34996  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
34997 
35000  MeshKit & UnsetAllUserData();
35001 
35003  size_t ShowUserDataCount() const;
35004 
35008  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
35009 
35014  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
35015 
35020  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
35021 
35022 };
35023 
35024 
35025 
35027 class HPS_API MeshKey : public GeometryKey
35028 {
35029 public:
35031  MeshKey();
35032 
35037  explicit MeshKey(Key const & in_that);
35038 
35041  MeshKey(MeshKey const & in_that);
35042 
35046  MeshKey & operator=(MeshKey const & in_that);
35047 
35051  MeshKey(MeshKey && in_that);
35052 
35056  MeshKey & operator=(MeshKey && in_that);
35057 
35058  ~MeshKey();
35059 
35060  HPS::Type ObjectType() const { return HPS::Type::MeshKey; };
35061 
35064  void Consume(MeshKit & in_kit);
35065 
35068  void Set(MeshKit const & in_kit);
35069 
35072  void Show(MeshKit & out_kit) const;
35073 
35076  size_t GetPointCount() const;
35077 
35083  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
35084 
35091  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
35092 
35096  bool ShowPoints(PointArray & out_points) const;
35097 
35103  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
35104 
35109  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
35110 
35116  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
35117 
35123  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
35124 
35128  bool ShowRows(size_t & out_rows) const;
35129 
35133  bool ShowColumns(size_t & out_columns) const;
35134 
35135 
35140  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
35141 
35144  MeshKey & UnsetMaterialMapping();
35145 
35149  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
35150 
35157  MeshKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool const in_visibilities[]);
35158 
35165  MeshKey & SetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], bool in_visibility);
35166 
35172  MeshKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, bool in_visibility);
35173 
35179  MeshKey & SetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray const & in_visibilities);
35180 
35186  MeshKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, FloatArray const & in_indices);
35187 
35193  MeshKey & SetEdgeIndexColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, float in_index);
35194 
35201  MeshKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float const in_indices[]);
35202 
35209  MeshKey & SetEdgeIndexColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], float in_index);
35210 
35216  MeshKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColorArray const & in_rgb_colors);
35217 
35223  MeshKey & SetEdgeRGBColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, RGBColor const & in_rgb_color);
35224 
35231  MeshKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_colors[]);
35232 
35239  MeshKey & SetEdgeRGBColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[], RGBColor const in_rgb_color);
35240 
35248  bool ShowEdgeColors(SizeTArray & out_vertices1, SizeTArray & out_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
35249 
35257  bool ShowEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, HPS::MaterialTypeArray & out_types, HPS::RGBColorArray & out_rgb_colors, HPS::FloatArray & out_indices);
35258 
35266  MeshKey & UnsetEdgeColors();
35267 
35272  MeshKey & UnsetEdgeColorsByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
35273 
35279  MeshKey & UnsetEdgeColorsByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
35280 
35283  MeshKey & UnsetEdgeVisibilities();
35284 
35287  MeshKey & UnsetEdgeEverything();
35288 
35293  MeshKey & UnsetEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2);
35294 
35300  MeshKey & UnsetEdgeVisibilitiesByList(size_t in_count, size_t const in_vertices1[], size_t const in_vertices2[]);
35301 
35302 
35311  bool ShowEdgeVisibilitiesByList(SizeTArray const & in_vertices1, SizeTArray const & in_vertices2, BoolArray & out_validities, BoolArray & out_visibilities) const;
35312 
35319  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35320 
35327  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35328 
35335  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35336 
35343  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35344 
35351  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35352 
35359  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35360 
35366  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35367 
35368 
35375  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35376 
35383  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35384 
35391  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35392 
35399  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35400 
35407  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
35408 
35415  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35416 
35422  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
35423 
35424 
35431  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35432 
35439  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
35440 
35447  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35448 
35455  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
35456 
35463  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
35464 
35471  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35472 
35478  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
35479 
35480 
35486  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
35487 
35493  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
35494 
35500  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
35501 
35507  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
35508 
35513  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
35514 
35520  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
35521 
35526  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
35527 
35528 
35536  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
35537 
35544  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
35545 
35554  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);
35555 
35563  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
35564 
35565 
35571  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
35572 
35578  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
35579 
35585  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
35586 
35592  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
35593 
35598  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
35599 
35605  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
35606 
35611  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
35612 
35613 
35616  MeshKey & UnsetVertexColors();
35617 
35622  MeshKey & UnsetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[]);
35623 
35628  MeshKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[]);
35629 
35635  MeshKey & UnsetVertexColorsByList(size_t in_count, size_t const in_vertices[], Mesh::Component in_apply_to);
35636 
35641  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
35642 
35646  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
35647 
35648 
35652  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
35653 
35659  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
35660 
35665  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
35666 
35667 
35670  MeshKey & UnsetVertexNormals();
35671 
35676  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
35677 
35681  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
35682 
35683 
35686  MeshKey & UnsetVertexParameters();
35687 
35692  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
35693 
35697  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
35698 
35699 
35702  MeshKey & UnsetVertexVisibilities();
35703 
35708  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
35709 
35713  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
35714 
35715 
35718  MeshKey & UnsetVertexEverything();
35719 
35722  MeshKey & UnsetEverything();
35723 
35724 
35736  bool ShowVertexColors(Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35737  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35738 
35752  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35753  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35754 
35769  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to, MaterialTypeArray & out_types,
35770  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
35771 
35772 
35779  bool ShowVertexNormals(BoolArray & out_validities, VectorArray & out_normals) const;
35780 
35789  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
35790 
35799  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
35800 
35808  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params) const;
35809 
35817  bool ShowVertexParameters(BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
35818 
35828  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
35829 
35839  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
35840 
35850  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
35851 
35861  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
35862 
35863 
35870  bool ShowVertexVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
35871 
35880  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
35881 
35890  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
35891 
35892 
35898  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
35899 
35905  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
35906 
35912  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
35913 
35919  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
35920 
35925  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
35926 
35932  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
35933 
35938  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
35939 
35940 
35946  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
35947 
35953  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
35954 
35960  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
35961 
35967  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
35968 
35973  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
35974 
35980  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
35981 
35986  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
35987 
35988 
35994  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
35995 
36001  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
36002 
36008  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
36009 
36015  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
36016 
36021  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
36022 
36028  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
36029 
36034  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
36035 
36036 
36042  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
36043 
36049  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
36050 
36056  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
36057 
36063  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
36064 
36069  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
36070 
36076  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
36077 
36082  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
36083 
36084 
36087  MeshKey & UnsetFaceColors();
36088 
36093  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
36094 
36098  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
36099 
36104  MeshKey & UnsetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[]);
36105 
36110  MeshKey & UnsetFaceColorsByList(size_t in_count, size_t const in_faces[]);
36111 
36114  MeshKey & UnsetFaceNormals();
36115 
36120  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
36121 
36125  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
36126 
36127 
36130  MeshKey & UnsetFaceVisibilities();
36131 
36136  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
36137 
36141  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
36142 
36143 
36146  MeshKey & UnsetFaceEverything();
36147 
36155  bool ShowFaceColors(MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36156 
36166  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36167 
36178  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
36179 
36186  bool ShowFaceNormals(BoolArray & out_validities, VectorArray & out_normals) const;
36187 
36196  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
36197 
36206  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
36207 
36214  bool ShowFaceVisibilities(BoolArray & out_validities, BoolArray & out_visibilities) const;
36215 
36224  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
36225 
36234  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
36235 
36244  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[]);
36245 
36253  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);
36254 };
36255 
36256 
36257 
36258 
36260 class HPS_API PolygonKit : public Kit
36261 {
36262 public:
36264  PolygonKit();
36265 
36268  PolygonKit(PolygonKit const & in_kit);
36269 
36273  PolygonKit(PolygonKit && in_that);
36274 
36278  PolygonKit & operator=(PolygonKit && in_that);
36279 
36280  virtual ~PolygonKit();
36281 
36282  HPS::Type ObjectType() const { return HPS::Type::PolygonKit; };
36283 
36286  void Consume(PolygonKit & in_kit);
36287 
36290  void Set(PolygonKit const & in_kit);
36291 
36294  void Show(PolygonKit & out_kit) const;
36295 
36299  PolygonKit & operator=(PolygonKit const & in_kit);
36300 
36303  bool Empty() const;
36304 
36308  bool Equals(PolygonKit const & in_kit) const;
36309 
36313  bool operator==(PolygonKit const & in_kit) const;
36314 
36318  bool operator!=(PolygonKit const & in_kit) const;
36319 
36322  size_t GetPointCount() const;
36323 
36330  PolygonKit & SetPriority(int in_priority);
36331 
36334  PolygonKit & UnsetPriority();
36335 
36339  bool ShowPriority(int & out_priority) const;
36340 
36341 
36345  PolygonKit & SetPoints(PointArray const & in_points);
36346 
36351  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
36352 
36355  PolygonKit & UnsetPoints();
36356 
36359  PolygonKit & UnsetEverything();
36360 
36364  bool ShowPoints(PointArray & out_points) const;
36365 
36371  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
36372 
36377  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
36378 
36384  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
36385 
36391  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
36392 
36397  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
36398 
36403  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
36404 
36410  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
36411 
36416  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
36417 
36423  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
36424 
36429  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
36430 
36435  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
36436 
36440  PolygonKit & UnsetUserData(intptr_t in_index);
36441 
36446  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
36447 
36451  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
36452 
36455  PolygonKit & UnsetAllUserData();
36456 
36458  size_t ShowUserDataCount() const;
36459 
36463  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
36464 
36469  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
36470 
36475  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
36476 };
36477 
36478 
36480 class HPS_API PolygonKey : public GeometryKey
36481 {
36482 public:
36484  PolygonKey();
36485 
36490  explicit PolygonKey(Key const & in_that);
36491 
36494  PolygonKey(PolygonKey const & in_that);
36495 
36499  PolygonKey & operator=(PolygonKey const & in_that);
36500 
36504  PolygonKey(PolygonKey && in_that);
36505 
36509  PolygonKey & operator=(PolygonKey && in_that);
36510 
36511  ~PolygonKey();
36512 
36513  HPS::Type ObjectType() const { return HPS::Type::PolygonKey; };
36514 
36515 
36518  void Consume(PolygonKit & in_kit);
36519 
36522  void Set(PolygonKit const & in_kit);
36523 
36526  void Show(PolygonKit & out_kit) const;
36527 
36530  size_t GetPointCount() const;
36531 
36535  PolygonKey & SetPoints(PointArray const & in_points);
36536 
36541  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
36542 
36546  bool ShowPoints(PointArray & out_points) const;
36547 
36553  bool ShowPointsByRange(size_t in_start_index, size_t in_count, PointArray & out_points) const;
36554 
36559  bool ShowPointsByList(SizeTArray const & in_indices, PointArray & out_points) const;
36560 
36566  bool ShowPointsByList(size_t in_count, size_t const in_indices[], PointArray & out_points) const;
36567 
36573  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
36574 
36579  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
36580 
36585  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
36586 
36592  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
36593 
36598  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
36599 };
36600 
36601 
36602 
36603 
36605 class HPS_API GridKit : public Kit
36606 {
36607 public:
36609  GridKit();
36610 
36613  GridKit(GridKit const & in_kit);
36614 
36617  GridKit(GridKit && in_that);
36618 
36619  virtual ~GridKit();
36620 
36621  HPS::Type ObjectType() const { return HPS::Type::GridKit; };
36622 
36625  void Consume(GridKit & in_kit);
36626 
36629  void Set(GridKit const & in_kit);
36630 
36633  void Show(GridKit & out_kit) const;
36634 
36638  GridKit & operator=(GridKit const & in_kit);
36639 
36643  GridKit & operator=(GridKit && in_that);
36644 
36647  bool Empty() const;
36648 
36652  bool Equals(GridKit const & in_kit) const;
36653 
36657  bool operator==(GridKit const & in_kit) const;
36658 
36662  bool operator!=(GridKit const & in_kit) const;
36663 
36664 
36671  GridKit & SetPriority(int in_priority);
36672 
36676  GridKit & SetType(Grid::Type in_type);
36677 
36681  GridKit & SetOrigin(Point const & in_origin);
36682 
36689  GridKit & SetFirstPoint(Point const & in_first_point);
36690 
36698  GridKit & SetSecondPoint(Point const & in_second_point);
36699 
36713  GridKit & SetFirstCount(int in_first_count);
36714 
36725  GridKit & SetSecondCount(int in_second_count);
36726 
36727 
36730  GridKit & UnsetPriority();
36731 
36734  GridKit & UnsetType();
36735 
36738  GridKit & UnsetOrigin();
36739 
36742  GridKit & UnsetFirstPoint();
36743 
36746  GridKit & UnsetSecondPoint();
36747 
36750  GridKit & UnsetFirstCount();
36751 
36754  GridKit & UnsetSecondCount();
36755 
36758  GridKit & UnsetEverything();
36759 
36760 
36764  bool ShowPriority(int & out_priority) const;
36765 
36769  bool ShowType(Grid::Type & out_type) const;
36770 
36774  bool ShowOrigin(Point & out_origin) const;
36775 
36779  bool ShowFirstPoint(Point & out_first_point) const;
36780 
36784  bool ShowSecondPoint(Point & out_second_point) const;
36785 
36789  bool ShowFirstCount(int & out_first_count) const;
36790 
36794  bool ShowSecondCount(int & out_second_count) const;
36795 
36801  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
36802 
36807  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
36808 
36813  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
36814 
36818  GridKit & UnsetUserData(intptr_t in_index);
36819 
36824  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
36825 
36829  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
36830 
36833  GridKit & UnsetAllUserData();
36834 
36836  size_t ShowUserDataCount() const;
36837 
36841  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
36842 
36847  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
36848 
36853  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
36854 };
36855 
36856 
36858 class HPS_API GridKey : public GeometryKey
36859 {
36860 public:
36862  GridKey();
36863 
36868  explicit GridKey(Key const & in_that);
36869 
36872  GridKey(GridKey const & in_that);
36873 
36876  GridKey(GridKey && in_that);
36877 
36881  GridKey & operator=(GridKey const & in_that);
36882 
36886  GridKey & operator=(GridKey && in_that);
36887 
36888  ~GridKey();
36889 
36890  HPS::Type ObjectType() const { return HPS::Type::GridKey; };
36891 
36894  void Consume(GridKit & in_kit);
36895 
36898  void Set(GridKit const & in_kit);
36899 
36902  void Show(GridKit & out_kit) const;
36903 
36904 
36908  GridKey & SetType(Grid::Type in_type);
36909 
36913  GridKey & SetOrigin(Point const & in_origin);
36914 
36921  GridKey & SetFirstPoint(Point const & in_first_point);
36922 
36930  GridKey & SetSecondPoint(Point const & in_second_point);
36931 
36945  GridKey & SetFirstCount(int in_first_count);
36946 
36957  GridKey & SetSecondCount(int in_second_count);
36958 
36959 
36960 
36964  bool ShowType(Grid::Type & out_type) const;
36965 
36969  bool ShowOrigin(Point & out_origin) const;
36970 
36974  bool ShowFirstPoint(Point & out_first_point) const;
36975 
36979  bool ShowSecondPoint(Point & out_second_point) const;
36980 
36984  bool ShowFirstCount(int & out_first_count) const;
36985 
36989  bool ShowSecondCount(int & out_second_count) const;
36990 };
36991 
36992 
36993 
36994 
36996 class HPS_API IncludeKey : public Key
36997 {
36998 public:
37000  IncludeKey();
37001 
37006  explicit IncludeKey(Key const & in_that);
37007 
37010  IncludeKey(IncludeKey const & in_that);
37011 
37015  IncludeKey & operator=(IncludeKey const & in_that);
37016 
37020  IncludeKey(IncludeKey && in_that);
37021 
37025  IncludeKey & operator=(IncludeKey && in_that);
37026 
37027  ~IncludeKey();
37028 
37029 
37030  HPS::Type ObjectType() const { return HPS::Type::IncludeKey; };
37031 
37034  SegmentKey GetTarget() const;
37035 
37036 
37041  IncludeKey & SetPriority(int in_priority);
37042 
37050  IncludeKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
37051 
37052 
37055  IncludeKey & UnsetPriority();
37056 
37059  IncludeKey & UnsetConditionalExpression();
37060 
37061 
37065  bool ShowPriority(int & out_priority) const;
37066 
37070  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
37071 
37077  IncludeKey & SetFilter(AttributeLock::Type in_type);
37078 
37085  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
37086 
37092  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
37093 
37099  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
37100 
37107  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
37108 
37114  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
37115 
37121  bool ShowFilter(AttributeLockTypeArray & out_types) const;
37122 
37128  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
37129 };
37130 
37131 
37132 
37134 class HPS_API StyleKey : public Key
37135 {
37136 public:
37138  StyleKey();
37139 
37144  explicit StyleKey(Key const & in_that);
37145 
37148  StyleKey(StyleKey const & in_that);
37149 
37153  StyleKey & operator=(StyleKey const & other);
37154 
37158  StyleKey(StyleKey && in_that);
37159 
37163  StyleKey & operator=(StyleKey && in_that);
37164 
37165  ~StyleKey();
37166 
37167  HPS::Type ObjectType() const { return HPS::Type::StyleKey; };
37168 
37169 
37175  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
37176 
37177 
37185  StyleKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
37186 
37187 
37190  StyleKey & UnsetConditionalExpression();
37191 
37192 
37196  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
37197 
37198 
37204  StyleKey & SetFilter(AttributeLock::Type in_type);
37205 
37212  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
37213 
37219  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
37220 
37226  StyleKey & UnsetFilter(AttributeLock::Type in_type);
37227 
37234  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
37235 
37241  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
37242 
37248  bool ShowFilter(AttributeLockTypeArray & out_types) const;
37249 
37255  bool ShowFilter(HPS::AttributeLock::Type in_type) const;
37256 };
37257 
37258 
37259 
37261 class HPS_API ReferenceKey : public GeometryKey
37262 {
37263 public:
37265  ReferenceKey();
37266 
37271  explicit ReferenceKey(Key const & in_that);
37272 
37275  ReferenceKey(ReferenceKey const & in_that);
37276 
37280  ReferenceKey & operator=(ReferenceKey const & in_that);
37281 
37285  ReferenceKey(ReferenceKey && in_that);
37286 
37290  ReferenceKey & operator=(ReferenceKey && in_that);
37291 
37292  ~ReferenceKey();
37293 
37294  HPS::Type ObjectType() const { return HPS::Type::ReferenceKey; };
37295 
37299  Key GetTarget() const;
37300 
37304  size_t ShowTargets(bool masked=true) const;
37305 
37310  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
37311 
37315  size_t ShowGeometryMask() const;
37316 
37321  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
37322 
37326  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
37327 
37330  ReferenceKey & UnsetGeometryMask();
37331 
37334  void SetModellingMatrix(MatrixKit const & in_kit);
37335 
37344  ReferenceKey & SetConditionalExpression(ConditionalExpression const & in_conditional);
37345 
37346 
37348  void UnsetModellingMatrix();
37349 
37352  ReferenceKey & UnsetConditionalExpression();
37353 
37354 
37358  bool ShowModellingMatrix(MatrixKit & out_kit) const;
37359 
37363  bool ShowConditionalExpression(ConditionalExpression & out_conditional) const;
37364 
37365 
37368  ModellingMatrixControl GetModellingMatrixControl();
37369 
37372  ModellingMatrixControl const GetModellingMatrixControl() const;
37373 };
37374 
37375 
37376 
37380 class HPS_API StandAloneWindowOptionsKit : public Kit
37381 {
37382 public:
37385 
37389 
37394 
37399 
37400  virtual ~StandAloneWindowOptionsKit();
37401 
37402  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsKit; };
37403 
37407  static StandAloneWindowOptionsKit GetDefault();
37408 
37411  void Set(StandAloneWindowOptionsKit const & in_kit);
37412 
37415  void Show(StandAloneWindowOptionsKit & out_kit) const;
37416 
37420  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
37421 
37424  bool Empty() const;
37425 
37429  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
37430 
37434  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
37435 
37439  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
37440 
37444  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
37445 
37450  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
37451 
37455  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
37456 
37461  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
37462 
37466  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
37467 
37471  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
37472 
37475  StandAloneWindowOptionsKit & UnsetDriver();
37476 
37479  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
37480 
37483  StandAloneWindowOptionsKit & UnsetTitle();
37484 
37487  StandAloneWindowOptionsKit & UnsetSubscreen();
37488 
37491  StandAloneWindowOptionsKit & UnsetMobility();
37492 
37495  StandAloneWindowOptionsKit & UnsetFullScreen();
37496 
37499  StandAloneWindowOptionsKit & UnsetEverything();
37500 
37504  bool ShowDriver(Window::Driver & out_driver) const;
37505 
37510  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37511 
37515  bool ShowTitle(UTF8 & out_window_name) const;
37516 
37520  bool ShowSubscreen(Rectangle & out_subscreen) const;
37521 
37525  bool ShowMobility(Window::Mobility & out_mobility) const;
37526 
37530  bool ShowFullScreen(bool & out_state) const;
37531 };
37532 
37533 
37534 
37541 {
37542 public:
37546 
37550 
37555 
37560 
37563 
37564  virtual HPS::Type Type() const { return ObjectType(); }
37565 
37566  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowOptionsControl; };
37567 
37572 
37577  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
37578 
37582  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
37583 
37587  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
37588 
37591  StandAloneWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
37592 
37594  StandAloneWindowOptionsControl & UnsetFallbackFonts();
37595 
37598  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
37599 
37603  bool ShowDriver(Window::Driver & out_driver) const;
37604 
37609  StandAloneWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
37610 
37615  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37616 
37620  bool ShowTitle(UTF8 & out_window_name) const;
37621 
37625  bool ShowSubscreen(Rectangle & out_subscreen) const;
37626 
37630  bool ShowMobility(Window::Mobility & out_mobility) const;
37631 
37635  bool ShowFullScreen(bool & out_state) const;
37636 
37640  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
37641 private:
37644 };
37645 
37646 
37647 
37651 class HPS_API OffScreenWindowOptionsKit : public Kit
37652 {
37653 public:
37656 
37660 
37665 
37669  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
37670 
37671  virtual ~OffScreenWindowOptionsKit();
37672 
37673  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsKit; };
37674 
37678  static OffScreenWindowOptionsKit GetDefault();
37679 
37682  void Set(OffScreenWindowOptionsKit const & in_kit);
37683 
37686  void Show(OffScreenWindowOptionsKit & out_kit) const;
37687 
37691  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
37692 
37695  bool Empty() const;
37696 
37700  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
37701 
37705  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
37706 
37710  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
37711 
37715  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
37716 
37721  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
37722 
37727  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
37728 
37733  OffScreenWindowOptionsKit & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
37734 
37739  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
37740 
37744  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
37745 
37749  OffScreenWindowOptionsKit & SetFramebufferRetention(bool in_retain);
37750 
37753  OffScreenWindowOptionsKit & UnsetDriver();
37754 
37757  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
37758 
37761  OffScreenWindowOptionsKit & UnsetHardwareResident();
37762 
37765  OffScreenWindowOptionsKit & UnsetNativeFormat();
37766 
37769  OffScreenWindowOptionsKit & UnsetOpacity();
37770 
37773  OffScreenWindowOptionsKit & UnsetFramebufferRetention();
37774 
37777  OffScreenWindowOptionsKit & UnsetEverything();
37778 
37782  bool ShowDriver(Window::Driver & out_driver) const;
37783 
37788  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37789 
37793  bool ShowHardwareResident(bool & out_state) const;
37794 
37799  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
37800 
37805  bool ShowOpacity(bool & out_state, float & out_opacity) const;
37806 
37810  bool ShowFramebufferRetention(bool & out_retain) const;
37811 };
37812 
37816 class HPS_API ApplicationWindowOptionsKit : public Kit
37817 {
37818 public:
37821 
37825 
37830 
37835 
37836  virtual ~ApplicationWindowOptionsKit();
37837 
37838  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsKit; };
37839 
37843  static ApplicationWindowOptionsKit GetDefault();
37844 
37847  void Set(ApplicationWindowOptionsKit const & in_kit);
37848 
37851  void Show(ApplicationWindowOptionsKit & out_kit) const;
37852 
37856  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
37857 
37860  bool Empty() const;
37861 
37865  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
37866 
37870  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
37871 
37875  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
37876 
37880  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
37881 
37886  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
37887 
37891  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
37892 
37896  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
37897 
37900  ApplicationWindowOptionsKit & UnsetDriver();
37901 
37904  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
37905 
37908  ApplicationWindowOptionsKit & UnsetPlatformData();
37909 
37912  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
37913 
37916  ApplicationWindowOptionsKit & UnsetEverything();
37917 
37921  bool ShowDriver(Window::Driver & out_driver) const;
37922 
37927  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37928 
37932  bool ShowPlatformData(PlatformData & out_platform_data) const;
37933 
37937  bool ShowFramebufferRetention(bool & out_retain) const;
37938 
37939 };
37940 
37941 
37942 
37945 {
37946 public:
37950 
37954 
37959 
37964 
37967 
37968  virtual HPS::Type Type() const { return ObjectType(); }
37969 
37970  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowOptionsControl; };
37971 
37976 
37979  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
37980 
37985  ApplicationWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
37986 
37991  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
37992 
37996  bool ShowDriver(Window::Driver & out_driver) const;
37997 
38001  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
38002 
38006  bool ShowPlatformData(PlatformData & out_platform_data) const;
38007 
38011  bool ShowFramebufferRetention(bool & out_retain) const;
38012 
38016  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
38017 
38021  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
38022 
38025  ApplicationWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
38026 
38028  ApplicationWindowOptionsControl & UnsetFallbackFonts();
38029 
38030 private:
38033 };
38034 
38035 
38036 
38041 class HPS_API StandAloneWindowKey : public WindowKey
38042 {
38043 public:
38046 
38051  StandAloneWindowKey(Key const & in_key);
38052 
38055  StandAloneWindowKey(StandAloneWindowKey const & in_that);
38056 
38061 
38065  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
38066 
38068 
38069  HPS::Type ObjectType() const { return HPS::Type::StandAloneWindowKey; };
38070 
38073  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
38074 
38077  StandAloneWindowOptionsControl GetWindowOptionsControl();
38078 
38082  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
38083 
38086  Window::UpdateStatus Pause();
38087 };
38088 
38089 
38090 
38092 class HPS_API ApplicationWindowKey : public WindowKey
38093 {
38094 public:
38097 
38102  ApplicationWindowKey(Key const & in_key);
38103 
38106  ApplicationWindowKey(ApplicationWindowKey const & in_that);
38107 
38112 
38116  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
38117 
38119 
38120  HPS::Type ObjectType() const { return HPS::Type::ApplicationWindowKey; };
38121 
38124  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
38125 
38128  ApplicationWindowOptionsControl GetWindowOptionsControl();
38129 
38133  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
38134 };
38135 
38139 
38140 
38141 
38143 class HPS_API GlyphElement : public Object
38144 {
38145 public:
38147  GlyphElement();
38148 
38151  GlyphElement(GlyphElement const & in_that);
38152 
38156  GlyphElement(GlyphElement && in_that);
38157 
38161  GlyphElement & operator=(GlyphElement && in_that);
38162 
38163  virtual ~GlyphElement();
38164 
38165  HPS::Type ObjectType() const { return HPS::Type::GlyphElement; };
38166 
38169  void Set(GlyphElement const & in_that);
38170 
38174  GlyphElement & operator=(GlyphElement const & in_that);
38175 
38179  bool Equals(GlyphElement const & in_that) const;
38180 
38184  bool operator==(GlyphElement const & in_that) const;
38185 
38189  bool operator!=(GlyphElement const & in_that) const;
38190 
38193  void SetFill(Glyph::Fill in_fill);
38194 
38197  void SetIndexedColor(byte in_index);
38198 
38200  void SetNormalColor();
38201 
38204  void SetExplicitColor(RGBAColor const & in_color);
38205 
38209  bool ShowFill(Glyph::Fill & out_fill) const;
38210 
38216  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
38217 };
38218 
38219 
38221 class HPS_API LineGlyphElement : public GlyphElement
38222 {
38223 public:
38225  LineGlyphElement();
38226 
38231  LineGlyphElement(GlyphElement const & in_that);
38232 
38235  LineGlyphElement(LineGlyphElement const & in_that);
38236 
38239  explicit LineGlyphElement(GlyphPointArray const & in_points);
38240 
38244  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
38245 
38249  LineGlyphElement(LineGlyphElement && in_that);
38250 
38254  LineGlyphElement & operator=(LineGlyphElement && in_that);
38255 
38256  ~LineGlyphElement();
38257 
38258  HPS::Type ObjectType() const { return HPS::Type::LineGlyphElement; };
38259 
38262  void SetPoints(GlyphPointArray const & in_points);
38263 
38267  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
38268 
38272  bool ShowPoints(GlyphPointArray & out_points) const;
38273 };
38274 
38276 class HPS_API DotGlyphElement : public GlyphElement
38277 {
38278 public:
38280  DotGlyphElement();
38281 
38286  DotGlyphElement(GlyphElement const & in_that);
38287 
38290  DotGlyphElement(DotGlyphElement const & in_that);
38291 
38294  explicit DotGlyphElement(GlyphPoint const & in_point);
38295 
38299  DotGlyphElement(DotGlyphElement && in_that);
38300 
38304  DotGlyphElement & operator=(DotGlyphElement && in_that);
38305 
38306  ~DotGlyphElement();
38307 
38308  HPS::Type ObjectType() const { return HPS::Type::DotGlyphElement; };
38309 
38312  void SetPoint(GlyphPoint const & in_point);
38313 
38317  bool ShowPoint(GlyphPoint & out_point) const;
38318 };
38319 
38320 
38322 class HPS_API EllipseGlyphElement : public GlyphElement
38323 {
38324 public:
38327 
38332  EllipseGlyphElement(GlyphElement const & in_that);
38333 
38336  EllipseGlyphElement(EllipseGlyphElement const & in_that);
38337 
38341  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
38342 
38347 
38351  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
38352 
38354 
38355  HPS::Type ObjectType() const { return HPS::Type::EllipseGlyphElement; };
38356 
38359  void SetLowerLeft(GlyphPoint const & in_point);
38360 
38363  void SetUpperRight(GlyphPoint const & in_point);
38364 
38368  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
38369 
38373  bool ShowLowerLeft(GlyphPoint & out_point) const;
38374 
38378  bool ShowUpperRight(GlyphPoint & out_point) const;
38379 };
38380 
38382 class HPS_API SphereGlyphElement : public GlyphElement
38383 {
38384 public:
38387 
38392  SphereGlyphElement(GlyphElement const & in_that);
38393 
38396  SphereGlyphElement(SphereGlyphElement const & in_that);
38397 
38402 
38406  SphereGlyphElement & operator=(SphereGlyphElement && in_that);
38407 
38408  ~SphereGlyphElement();
38409 
38410  HPS::Type ObjectType() const { return HPS::Type::SphereGlyphElement; };
38411 };
38412 
38413 
38416 {
38417 public:
38420 
38425  CircularArcGlyphElement(GlyphElement const & in_that);
38426 
38430 
38435  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
38436 
38441 
38445  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
38446 
38448 
38449  HPS::Type ObjectType() const { return HPS::Type::CircularArcGlyphElement; };
38450 
38453  void SetStartPoint(GlyphPoint const & in_point);
38454 
38457  void SetIntermediatePoint(GlyphPoint const & in_point);
38458 
38461  void SetEndPoint(GlyphPoint const & in_point);
38462 
38467  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
38468 
38472  bool ShowStartPoint(GlyphPoint & out_point) const;
38473 
38477  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
38478 
38482  bool ShowEndPoint(GlyphPoint & out_point) const;
38483 };
38484 
38485 
38486 
38489 {
38490 public:
38493 
38498  InfiniteLineGlyphElement(GlyphElement const & in_that);
38499 
38503 
38508  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
38509 
38514 
38518  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
38519 
38521 
38522  HPS::Type ObjectType() const { return HPS::Type::InfiniteLineGlyphElement; };
38523 
38526  void SetFirstPoint(GlyphPoint const & in_point);
38527 
38530  void SetSecondPoint(GlyphPoint const & in_point);
38531 
38535  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
38536 
38539  void SetInfiniteType(InfiniteLine::Type in_type);
38540 
38544  bool ShowFirstPoint(GlyphPoint & out_point) const;
38545 
38549  bool ShowSecondPoint(GlyphPoint & out_point) const;
38550 
38554  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
38555 };
38556 
38557 
38558 
38560 class HPS_API GlyphKit : public Kit
38561 {
38562 public:
38564  GlyphKit();
38565 
38568  GlyphKit(GlyphKit const & in_kit);
38569 
38573  GlyphKit(GlyphKit && in_that);
38574 
38578  GlyphKit & operator=(GlyphKit && in_that);
38579 
38580  virtual ~GlyphKit();
38581 
38582  HPS::Type ObjectType() const { return HPS::Type::GlyphKit; };
38583 
38587  static HPS::GlyphKit GetDefault(Glyph::Default in_default_glyph);
38588 
38591  void Set(GlyphKit const & in_kit);
38592 
38595  void Show(GlyphKit & out_kit) const;
38596 
38600  GlyphKit & operator=(GlyphKit const & in_kit);
38601 
38604  bool Empty() const;
38605 
38609  bool Equals(GlyphKit const & in_kit) const;
38610 
38614  bool operator==(GlyphKit const & in_kit) const;
38615 
38619  bool operator!=(GlyphKit const & in_kit) const;
38620 
38624  GlyphKit & SetRadius(sbyte in_radius);
38625 
38630  GlyphKit & SetOffset(GlyphPoint const & in_point);
38631 
38635  GlyphKit & SetElements(GlyphElementArray const & in_def);
38636 
38641  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
38642 
38646  GlyphKit & SetElement(GlyphElement const & in_element);
38647 
38650  GlyphKit & UnsetRadius();
38651 
38654  GlyphKit & UnsetOffset();
38655 
38658  GlyphKit & UnsetElements();
38659 
38662  GlyphKit & UnsetEverything();
38663 
38667  bool ShowRadius(sbyte & out_radius) const;
38668 
38672  bool ShowOffset(GlyphPoint & out_point) const;
38673 
38677  bool ShowElements(GlyphElementArray & out_def) const;
38678 };
38679 
38683 
38684 
38687 class HPS_API LinePatternOptionsKit : public Kit
38688 {
38689 public:
38692 
38696 
38701 
38705  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
38706 
38707  virtual ~LinePatternOptionsKit();
38708 
38709  HPS::Type ObjectType() const { return HPS::Type::LinePatternOptionsKit; };
38710 
38713  void Set(LinePatternOptionsKit const & in_kit);
38714 
38717  void Show(LinePatternOptionsKit & out_kit) const;
38718 
38722  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
38723 
38726  bool Empty() const;
38727 
38731  bool Equals(LinePatternOptionsKit const & in_kit) const;
38732 
38736  bool operator==(LinePatternOptionsKit const & in_kit) const;
38737 
38741  bool operator!=(LinePatternOptionsKit const & in_kit) const;
38742 
38746  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
38747 
38751  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
38752 
38756  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
38757 
38761  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
38762 
38766  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
38767 
38771  LinePatternOptionsKit & SetJoin(char const * in_glyph);
38772 
38776  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
38777 
38781  LinePatternOptionsKit & UnsetStartCap();
38782 
38786  LinePatternOptionsKit & UnsetEndCap();
38787 
38790  LinePatternOptionsKit & UnsetInnerCap();
38791 
38795  LinePatternOptionsKit & UnsetJoin();
38796 
38799  LinePatternOptionsKit & UnsetEverything();
38800 
38806  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
38807 
38813  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
38814 
38818  bool ShowInnerCap(LinePattern::Cap & out_type) const;
38819 
38825  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
38826 };
38827 
38830 class HPS_API LinePatternElement : public Object
38831 {
38832 public:
38835 
38838  LinePatternElement(LinePatternElement const & in_that);
38839 
38844 
38848  LinePatternElement & operator=(LinePatternElement && in_that);
38849 
38850  ~LinePatternElement();
38851 
38852  HPS::Type ObjectType() const { return HPS::Type::LinePatternElement; };
38853 
38856  void Set(LinePatternElement const & in_that);
38857 
38861  LinePatternElement & operator=(LinePatternElement const & in_that);
38862 
38866  bool Equals(LinePatternElement const & in_that) const;
38867 
38871  bool operator==(LinePatternElement const & in_that) const;
38872 
38876  bool operator!=(LinePatternElement const & in_that) const;
38877 
38881  void SetSize(float in_size, LinePattern::SizeUnits in_units);
38882 
38887  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
38888 };
38889 
38892 {
38893 public:
38896 
38902 
38906 
38910  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
38911 
38916 
38920  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
38921 
38923 
38924  HPS::Type ObjectType() const { return HPS::Type::SolidLinePatternElement; };
38925 
38929  void SetColor(RGBAColor const & in_color);
38930 
38934  void SetMaterialByIndex(float in_material_index);
38935 
38941  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
38942 };
38943 
38944 
38947 {
38948 public:
38951 
38957 
38961 
38965  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
38966 
38971 
38975  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
38976 
38978 
38979  HPS::Type ObjectType() const { return HPS::Type::BlankLinePatternElement; };
38980 };
38981 
38982 
38985 {
38986 public:
38989 
38995 
38999 
39003  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
39004 
39009 
39013  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
39014 
39016 
39017  HPS::Type ObjectType() const { return HPS::Type::GlyphLinePatternElement; };
39018 
39021  void SetSource(char const * in_source);
39022 
39026  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
39027 
39030  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
39031 
39034  void SetMirror(bool in_state);
39035 
39038  void SetFixed(bool in_state);
39039 
39042  void SetRotation(float in_degrees);
39043 
39047  bool ShowSource(UTF8 & out_source) const;
39048 
39053  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
39054 
39058  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
39059 
39063  bool ShowMirror(bool & out_state) const;
39064 
39068  bool ShowFixed(bool & out_state) const;
39069 
39073  bool ShowRotation(float & out_degrees) const;
39074 };
39075 
39077 class HPS_API LinePatternParallelKit : public Kit
39078 {
39079 public:
39082 
39086 
39091 
39095  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
39096 
39097  virtual ~LinePatternParallelKit();
39098 
39099  HPS::Type ObjectType() const { return HPS::Type::LinePatternParallelKit; };
39100 
39103  void Set(LinePatternParallelKit const & in_kit);
39104 
39107  void Show(LinePatternParallelKit & out_kit) const;
39108 
39112  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
39113 
39116  bool Empty() const;
39117 
39121  bool Equals(LinePatternParallelKit const & in_kit) const;
39122 
39126  bool operator==(LinePatternParallelKit const & in_kit) const;
39127 
39131  bool operator!=(LinePatternParallelKit const & in_kit) const;
39132 
39136  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
39137 
39141  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
39142 
39146  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
39147 
39151  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
39152 
39157  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
39158 
39162  LinePatternParallelKit & SetBody(LinePatternElement const & in_element);
39163 
39167  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
39168 
39172  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
39173 
39177  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
39178 
39185  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
39186 
39192  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
39193 
39197  LinePatternParallelKit & SetContinuous(bool in_state);
39198 
39201  LinePatternParallelKit & UnsetStartCap();
39202 
39205  LinePatternParallelKit & UnsetEndCap();
39206 
39209  LinePatternParallelKit & UnsetJoin();
39210 
39213  LinePatternParallelKit & UnsetBody();
39214 
39217  LinePatternParallelKit & UnsetAbsoluteLength();
39218 
39221  LinePatternParallelKit & UnsetAbsoluteWeight();
39222 
39225  LinePatternParallelKit & UnsetJustification();
39226 
39229  LinePatternParallelKit & UnsetOffset();
39230 
39233  LinePatternParallelKit & UnsetWeight();
39234 
39237  LinePatternParallelKit & UnsetContinuous();
39238 
39241  LinePatternParallelKit & UnsetEverything();
39242 
39246  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
39247 
39251  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
39252 
39256  bool ShowJoin(GlyphLinePatternElement & out_join) const;
39257 
39261  bool ShowBody(LinePatternElementArray & out_elements) const;
39262 
39266  bool ShowAbsoluteLength(bool & out_state) const;
39267 
39271  bool ShowAbsoluteWeight(bool & out_state) const;
39272 
39276  bool ShowJustification(LinePattern::Justification & out_type) const;
39277 
39283  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
39284 
39290  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
39291 
39295  bool ShowContinuous(bool & out_state) const;
39296 };
39297 
39298 
39300 class HPS_API LinePatternKit : public Kit
39301 {
39302 public:
39304  LinePatternKit();
39305 
39308  LinePatternKit(LinePatternKit const & in_kit);
39309 
39313  LinePatternKit(LinePatternKit && in_that);
39314 
39318  LinePatternKit & operator=(LinePatternKit && in_that);
39319 
39320  virtual ~LinePatternKit();
39321 
39322  HPS::Type ObjectType() const { return HPS::Type::LinePatternKit; };
39323 
39327  static HPS::LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
39328 
39331  void Set(LinePatternKit const & in_kit);
39332 
39335  void Show(LinePatternKit & out_kit) const;
39336 
39340  LinePatternKit & operator=(LinePatternKit const & in_kit);
39341 
39344  bool Empty() const;
39345 
39349  bool Equals(LinePatternKit const & in_kit) const;
39350 
39354  bool operator==(LinePatternKit const & in_kit) const;
39355 
39359  bool operator!=(LinePatternKit const & in_kit) const;
39360 
39364  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
39365 
39370  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
39371 
39375  LinePatternKit & SetParallel(LinePatternParallelKit const & in_parallel);
39376 
39380  LinePatternKit & SetJoin(LinePattern::Join in_type);
39381 
39384  LinePatternKit & UnsetParallels();
39385 
39388  LinePatternKit & UnsetJoin();
39389 
39392  LinePatternKit & UnsetEverything();
39393 
39397  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
39398 
39402  bool ShowJoin(LinePattern::Join & out_type) const;
39403 };
39404 
39405 
39409 
39411 class HPS_API ShapeElement : public Object
39412 {
39413 public:
39415  ShapeElement();
39416 
39419  ShapeElement(ShapeElement const & in_that);
39420 
39424  ShapeElement(ShapeElement && in_that);
39425 
39429  ShapeElement & operator=(ShapeElement && in_that);
39430 
39431  virtual ~ShapeElement();
39432 
39433  HPS::Type ObjectType() const { return HPS::Type::ShapeElement; };
39434 
39437  void Set(ShapeElement const & in_that);
39438 
39442  ShapeElement & operator=(ShapeElement const & in_that);
39443 
39447  bool Equals(ShapeElement const & in_that) const;
39448 
39452  bool operator==(ShapeElement const & in_that) const;
39453 
39457  bool operator!=(ShapeElement const & in_that) const;
39458 
39463  ShapeElement & SetDisjointed(bool in_state);
39464 
39470  bool ShowDisjointed(bool & out_state) const;
39471 
39475  ShapeElement & SetFill(bool in_state);
39476 
39481  bool ShowFill(bool & out_state) const;
39482 };
39483 
39485 class HPS_API PolygonShapeElement : public ShapeElement
39486 {
39487 public:
39490 
39495  PolygonShapeElement(ShapeElement const & in_that);
39496 
39499  PolygonShapeElement(PolygonShapeElement const & in_that);
39500 
39503  explicit PolygonShapeElement(ShapePointArray const & in_points);
39504 
39508  PolygonShapeElement(size_t in_count, ShapePoint const in_points[]);
39509 
39514 
39518  PolygonShapeElement & operator=(PolygonShapeElement && in_that);
39519 
39521 
39522  HPS::Type ObjectType() const { return HPS::Type::PolygonShapeElement; };
39523 
39526  PolygonShapeElement & SetPoints(ShapePointArray const & in_points);
39527 
39531  PolygonShapeElement & SetPoints(size_t in_count, ShapePoint const in_points[]);
39532 
39536  bool ShowPoints(ShapePointArray & out_points) const;
39537 };
39538 
39539 
39541 class HPS_API EllipseShapeElement : public ShapeElement
39542 {
39543 public:
39546 
39551  EllipseShapeElement(ShapeElement const & in_that);
39552 
39555  EllipseShapeElement(EllipseShapeElement const & in_that);
39556 
39561  explicit EllipseShapeElement(ShapePoint const & in_center, ShapePoint const & in_major_axis_point, ShapePoint const & in_minor_axis_point);
39562 
39567 
39571  EllipseShapeElement & operator=(EllipseShapeElement && in_that);
39572 
39574 
39575  HPS::Type ObjectType() const { return HPS::Type::EllipseShapeElement; };
39576 
39579  EllipseShapeElement & SetCenter(ShapePoint const & in_center);
39580 
39584  bool ShowCenter(ShapePoint & out_center) const;
39585 
39588  EllipseShapeElement & SetMinorAxisPoint(ShapePoint const & in_minor_axis_point);
39589 
39593  bool ShowMinorAxisPoint(ShapePoint & out_minor_axis_point) const;
39594 
39597  EllipseShapeElement & SetMajorAxisPoint(ShapePoint const & in_major_axis_point);
39598 
39602  bool ShowMajorAxisPoint(ShapePoint & out_major_axis_point) const;
39603 };
39604 
39606 class HPS_API CircleShapeElement : public ShapeElement
39607 {
39608 public:
39611 
39616  CircleShapeElement(ShapeElement const & in_that);
39617 
39620  CircleShapeElement(CircleShapeElement const & in_that);
39621 
39625  explicit CircleShapeElement(ShapePoint const & in_center, ShapePoint const & in_radius);
39626 
39631 
39635  CircleShapeElement & operator=(CircleShapeElement && in_that);
39636 
39637  ~CircleShapeElement();
39638 
39639  HPS::Type ObjectType() const { return HPS::Type::CircleShapeElement; };
39640 
39643  CircleShapeElement & SetCenter(ShapePoint const & in_center);
39644 
39648  bool ShowCenter(ShapePoint & out_center) const;
39649 
39652  CircleShapeElement & SetRadius(ShapePoint const & in_radius);
39653 
39657  bool ShowRadius(ShapePoint & out_radius) const;
39658 };
39659 
39662 {
39663 public:
39666 
39671  EllipticalArcShapeElement(ShapeElement const & in_that);
39672 
39676 
39683  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);
39684 
39689 
39693  EllipticalArcShapeElement & operator=(EllipticalArcShapeElement && in_that);
39694 
39696 
39697  HPS::Type ObjectType() const { return HPS::Type::EllipticalArcShapeElement; };
39698 
39701  EllipticalArcShapeElement & SetCenter(ShapePoint const & in_center);
39702 
39706  bool ShowCenter(ShapePoint & out_center) const;
39707 
39710  EllipticalArcShapeElement & SetMinorAxisPoint(ShapePoint const & in_minor_axis_point);
39711 
39715  bool ShowMinorAxisPoint(ShapePoint & out_minor_axis_point) const;
39716 
39719  EllipticalArcShapeElement & SetMajorAxisPoint(ShapePoint const & in_major_axis_point);
39720 
39724  bool ShowMajorAxisPoint(ShapePoint & out_major_axis_point) const;
39725 
39728  EllipticalArcShapeElement & SetStart(float in_start);
39729 
39733  bool ShowStart(float & out_start) const;
39734 
39737  EllipticalArcShapeElement & SetEnd(float in_end);
39738 
39742  bool ShowEnd(float & out_end) const;
39743 };
39744 
39747 {
39748 public:
39751 
39756  CircularArcShapeElement(ShapeElement const & in_that);
39757 
39761 
39766  explicit CircularArcShapeElement(ShapePoint const & in_start_point, ShapePoint const & in_middle_point, ShapePoint const & in_end_point);
39767 
39772 
39776  CircularArcShapeElement & operator=(CircularArcShapeElement && in_that);
39777 
39779 
39780  HPS::Type ObjectType() const { return HPS::Type::CircularArcShapeElement; };
39781 
39784  CircularArcShapeElement & SetStartPoint(ShapePoint const & in_start);
39785 
39789  bool ShowStartPoint(ShapePoint & out_start) const;
39790 
39793  CircularArcShapeElement & SetMiddlePoint(ShapePoint const & in_middle);
39794 
39798  bool ShowMiddlePoint(ShapePoint & out_middle) const;
39799 
39802  CircularArcShapeElement & SetEndPoint(ShapePoint const & in_end);
39803 
39807  bool ShowEndPoint(ShapePoint & out_end) const;
39808 };
39809 
39814 class HPS_API AnchorShapeElement : public ShapeElement
39815 {
39816 public:
39819 
39824  AnchorShapeElement(ShapeElement const & in_that);
39825 
39828  AnchorShapeElement(AnchorShapeElement const & in_that);
39829 
39832  explicit AnchorShapeElement(ShapePoint const & in_anchor_point);
39833 
39838  explicit AnchorShapeElement(ShapePoint const & in_anchor_point, ShapePointArray const & in_intermediate_points, bool in_connection);
39839 
39844 
39848  AnchorShapeElement & operator=(AnchorShapeElement && in_that);
39849 
39850  ~AnchorShapeElement();
39851 
39852  HPS::Type ObjectType() const { return HPS::Type::AnchorShapeElement; };
39853 
39856  AnchorShapeElement & SetAnchor(ShapePoint const & in_anchor);
39857 
39861  bool ShowAnchor(ShapePoint & out_anchor) const;
39862 
39865  AnchorShapeElement & SetIntermediatePoints(ShapePointArray const & in_intermediate_points);
39866 
39870  bool ShowIntermediatePoints(ShapePointArray & out_intermediate_points) const;
39871 
39873  AnchorShapeElement & UnsetIntermediatePoints();
39874 
39877  AnchorShapeElement & SetConnection(bool in_connection);
39878 
39882  bool ShowConnection(bool & out_connection) const;
39883 
39885  AnchorShapeElement & UnsetConnection();
39886 };
39887 
39888 
39890 class HPS_API LineShapeElement : public ShapeElement
39891 {
39892 public:
39894  LineShapeElement();
39895 
39900  LineShapeElement(ShapeElement const & in_that);
39901 
39904  LineShapeElement(LineShapeElement const & in_that);
39905 
39908  explicit LineShapeElement(ShapePointArray const & in_points);
39909 
39913  LineShapeElement(size_t in_count, ShapePoint const in_points []);
39914 
39918  LineShapeElement(ShapePoint const & in_start, ShapePoint const & in_end);
39919 
39923  LineShapeElement(LineShapeElement && in_that);
39924 
39928  LineShapeElement & operator=(LineShapeElement && in_that);
39929 
39930  ~LineShapeElement();
39931 
39932  HPS::Type ObjectType() const { return HPS::Type::LineShapeElement; };
39933 
39936  LineShapeElement & SetPoints(ShapePointArray const & in_points);
39937 
39941  LineShapeElement & SetPoints(size_t in_count, ShapePoint const in_points []);
39942 
39946  bool ShowPoints(ShapePointArray & out_points) const;
39947 };
39948 
39952 
39953 
39955 class HPS_API Definition : public Object
39956 {
39957 public:
39959  Definition();
39960 
39963  Definition(Definition const & in_that);
39964 
39968  Definition & operator=(Definition const & in_that);
39969 
39973  Definition(Definition && in_that);
39974 
39978  Definition & operator=(Definition && in_that);
39979 
39980  virtual ~Definition();
39981 
39982  HPS::Type ObjectType() const { return HPS::Type::Definition; };
39983 
39985  void Undefine();
39986 
39989  PortfolioKey Owner() const;
39990 
39993  UTF8 Name() const;
39994 
39997  virtual void Assign(Definition const & in_that);
39998 
40002  bool Equals(Definition const & in_that) const;
40003 
40007  bool operator==(Definition const & in_that) const;
40008 
40012  bool operator!=(Definition const & in_that) const;
40013 };
40014 
40015 
40018 class HPS_API PortfolioKey : public Key
40019 {
40020 public:
40022  PortfolioKey();
40023 
40028  explicit PortfolioKey(Key const & in_that);
40029 
40032  PortfolioKey(PortfolioKey const & in_that);
40033 
40037  PortfolioKey & operator=(PortfolioKey const & in_that);
40038 
40042  PortfolioKey(PortfolioKey && in_that);
40043 
40047  PortfolioKey & operator=(PortfolioKey && in_that);
40048 
40049  ~PortfolioKey();
40050 
40051  HPS::Type ObjectType() const { return HPS::Type::PortfolioKey; };
40052 
40053  // Define
40054 
40061  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
40062 
40070  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
40071 
40072 
40084  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
40085  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
40086  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
40087 
40100  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
40101  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
40102  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
40103 
40104 
40110  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
40111 
40112 
40118  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
40119 
40120 
40126  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
40127 
40134  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
40135 
40136 
40142  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
40143 
40144 
40150  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
40151 
40152 
40158  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
40159 
40165  ShapeDefinition DefineShape(char const * in_name, ShapeKit const & in_source);
40166 
40167  // UnDefine
40168 
40172  PortfolioKey & UndefineTexture(char const * in_name);
40173 
40177  PortfolioKey & UndefineCubeMap(char const * in_name);
40178 
40182  PortfolioKey & UndefineImage(char const * in_name);
40183 
40187  PortfolioKey & UndefineNamedStyle(char const * in_name);
40188 
40192  PortfolioKey & UndefineMaterialPalette(char const * in_name);
40193 
40197  PortfolioKey & UndefineGlyph(char const * in_name);
40198 
40202  PortfolioKey & UndefineLinePattern(char const * in_name);
40203 
40207  PortfolioKey & UndefineShader(char const * in_name);
40208 
40212  PortfolioKey & UndefineShape(char const * in_name);
40213 
40214  // Import collections
40220  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40221 
40222 
40228  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40229 
40235  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40236 
40242  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40243 
40249  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40250 
40256  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40257 
40263  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40264 
40270  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40271 
40277  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40278 
40284  PortfolioKey & ImportAllShapes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
40285 
40286 
40287  // Import individual definitions
40291  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
40292 
40296  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
40297 
40301  ImageDefinition ImportImage(ImageDefinition const & in_definition);
40302 
40306  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
40307 
40311  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
40312 
40316  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
40317 
40321  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
40322 
40326  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
40327 
40331  ShapeDefinition ImportShape(ShapeDefinition const & in_definition);
40332 
40333 
40334  // Show
40336  size_t GetDefinitionCount() const;
40337 
40339  size_t GetTextureDefinitionCount() const;
40340 
40342  size_t GetCubeMapDefinitionCount() const;
40343 
40345  size_t GetImageDefinitionCount() const;
40346 
40348  size_t GetNamedStyleDefinitionCount() const;
40349 
40351  size_t GetMaterialPaletteDefinitionCount() const;
40352 
40354  size_t GetGlyphDefinitionCount() const;
40355 
40357  size_t GetLinePatternDefinitionCount() const;
40358 
40361  size_t GetShaderDefinitionCount() const;
40362 
40364  size_t GetShapeDefinitionCount() const;
40365 
40369  bool ShowTextureDefinition(char const * in_name) const;
40370 
40375  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
40376 
40380  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
40381 
40385  bool ShowCubeMapDefinition(char const * in_name) const;
40386 
40391  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
40392 
40396  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
40397 
40401  bool ShowImageDefinition(char const * in_name) const;
40402 
40407  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
40408 
40412  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
40413 
40417  bool ShowNamedStyleDefinition(char const * in_name) const;
40418 
40423  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
40424 
40428  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
40429 
40433  bool ShowMaterialPaletteDefinition(char const * in_name) const;
40434 
40439  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
40440 
40444  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
40445 
40449  bool ShowGlyphDefinition(char const * in_name) const;
40450 
40455  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
40456 
40460  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
40461 
40465  bool ShowLinePatternDefinition(char const * in_name) const;
40466 
40471  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
40472 
40476  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
40477 
40481  bool ShowShaderDefinition(char const * in_name) const;
40482 
40487  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
40488 
40492  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
40493 
40497  bool ShowShapeDefinition(char const * in_name) const;
40498 
40503  bool ShowShapeDefinition(char const * in_name, ShapeDefinition & out_found) const;
40504 
40508  bool ShowAllShapeDefinitions(ShapeDefinitionArray & out_definitions) const;
40509 
40510 private:
40512  void MoveTo(SegmentKey const & in_new_owner);
40513 
40515  Key CopyTo(SegmentKey const & in_destination) const;
40516 };
40517 
40518 
40519 
40521 class HPS_API GlyphDefinition : public Definition
40522 {
40523 public:
40525  GlyphDefinition();
40526 
40531  GlyphDefinition(Definition const & in_that);
40532 
40535  GlyphDefinition(GlyphDefinition const & in_that);
40536 
40540  GlyphDefinition & operator=(GlyphDefinition const & in_that);
40541 
40545  GlyphDefinition(GlyphDefinition && in_that);
40546 
40550  GlyphDefinition & operator=(GlyphDefinition && in_that);
40551 
40552  ~GlyphDefinition();
40553 
40554  HPS::Type ObjectType() const { return HPS::Type::GlyphDefinition; };
40555 
40558  void Set(GlyphKit const & in_kit);
40559 
40562  void Show(GlyphKit & out_kit) const;
40563 };
40564 
40565 
40567 class HPS_API TextureDefinition : public Definition
40568 {
40569 public:
40572 
40577  TextureDefinition(Definition const & in_that);
40578 
40581  TextureDefinition(TextureDefinition const & in_that);
40582 
40586  TextureDefinition & operator=(TextureDefinition const & in_that);
40587 
40592 
40596  TextureDefinition & operator=(TextureDefinition && in_that);
40597 
40598  ~TextureDefinition();
40599 
40600  HPS::Type ObjectType() const { return HPS::Type::TextureDefinition; };
40601 
40604  void SetSource(ImageDefinition const & in_source);
40605 
40609  bool ShowSource(ImageDefinition & out_source) const;
40610 
40616  bool ShowSource(UTF8 & out_source) const;
40617 
40620  void SetOptions(TextureOptionsKit const & in_options);
40621 
40624  void ShowOptions(TextureOptionsKit & out_options) const;
40625 
40626 };
40627 
40631 class HPS_API TextureOptionsKit : public Kit
40632 {
40633 public:
40636 
40639  TextureOptionsKit(TextureOptionsKit const & in_kit);
40640 
40645 
40649  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
40650 
40651  virtual ~TextureOptionsKit();
40652 
40653  HPS::Type ObjectType() const { return HPS::Type::TextureOptionsKit; };
40654 
40658  static TextureOptionsKit GetDefault();
40659 
40662  void Set(TextureOptionsKit const & in_kit);
40663 
40666  void Show(TextureOptionsKit & out_kit) const;
40667 
40671  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
40672 
40675  bool Empty() const;
40676 
40680  bool Equals(TextureOptionsKit const & in_kit) const;
40681 
40685  bool operator==(TextureOptionsKit const & in_kit) const;
40686 
40690  bool operator!=(TextureOptionsKit const & in_kit) const;
40691 
40696  TextureOptionsKit & SetDecal(bool in_state);
40697 
40701  TextureOptionsKit & SetDownSampling(bool in_state);
40702 
40706  TextureOptionsKit & SetModulation(bool in_state);
40707 
40711  TextureOptionsKit & SetParameterOffset(size_t in_offset);
40712 
40716  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
40717 
40721  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
40722 
40726  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
40727 
40731  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
40732 
40736  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
40737 
40740  TextureOptionsKit & UnsetDecal();
40741 
40744  TextureOptionsKit & UnsetDownSampling();
40745 
40748  TextureOptionsKit & UnsetModulation();
40749 
40752  TextureOptionsKit & UnsetParameterOffset();
40753 
40756  TextureOptionsKit & UnsetParameterizationSource();
40757 
40760  TextureOptionsKit & UnsetTiling();
40761 
40764  TextureOptionsKit & UnsetInterpolationFilter();
40765 
40768  TextureOptionsKit & UnsetDecimationFilter();
40769 
40772  TextureOptionsKit & UnsetTransformMatrix();
40773 
40776  TextureOptionsKit & UnsetEverything();
40777 
40781  bool ShowDecal(bool & out_state) const;
40782 
40786  bool ShowDownSampling(bool & out_state) const;
40787 
40791  bool ShowModulation(bool & out_state) const;
40792 
40796  bool ShowParameterOffset(size_t & out_offset) const;
40797 
40801  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
40802 
40806  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
40807 
40811  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
40812 
40816  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
40817 
40821  bool ShowTransformMatrix(MatrixKit & out_transform) const;
40822 };
40823 
40824 
40826 class HPS_API Image
40827 {
40828 public:
40831  enum class Format : uint32_t
40832  {
40833  RGB,
40834  RGBA,
40835  ARGB,
40836  Mapped8,
40837  Grayscale,
40838  Bmp,
40839  Jpeg,
40840  Png,
40841  Targa,
40842  DXT1,
40843  DXT3,
40844  DXT5
40845  };
40846 
40848 class HPS_API ExportOptionsKit : public Kit
40849  {
40850  public:
40852  ExportOptionsKit();
40853 
40856  ExportOptionsKit(ExportOptionsKit const & in_kit);
40857 
40861  ExportOptionsKit(ExportOptionsKit && in_that);
40862 
40866  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
40867 
40868  virtual ~ExportOptionsKit();
40869 
40870  HPS::Type ObjectType() const { return HPS::Type::ImageExportOptionsKit; };
40871 
40875  static ExportOptionsKit GetDefault();
40876 
40879  void Set(ExportOptionsKit const & in_kit);
40880 
40883  void Show(ExportOptionsKit & out_kit) const;
40884 
40888  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
40889 
40892  bool Empty() const;
40893 
40897  bool Equals(ExportOptionsKit const & in_kit) const;
40898 
40902  bool operator==(ExportOptionsKit const & in_kit) const;
40903 
40907  bool operator!=(ExportOptionsKit const & in_kit) const;
40908 
40913  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
40914 
40919  ExportOptionsKit & SetFormat(Image::Format in_format);
40920 
40925  ExportOptionsKit & SetTransparentBackground(bool in_state);
40926 
40929  ExportOptionsKit & UnsetSize();
40930 
40933  ExportOptionsKit & UnsetFormat();
40934 
40937  ExportOptionsKit & UnsetTransparentBackground();
40938 
40941  ExportOptionsKit & UnsetEverything();
40942 
40947  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
40948 
40952  bool ShowFormat(Image::Format & out_format) const;
40953 
40957  bool ShowTransparentBackground(bool & out_state) const;
40958  };
40959 
40961 class HPS_API ImportOptionsKit : public Kit
40962  {
40963  public:
40965  ImportOptionsKit();
40966 
40969  ImportOptionsKit(ImportOptionsKit const & in_kit);
40970 
40974  ImportOptionsKit(ImportOptionsKit && in_that);
40975 
40979  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
40980 
40981  virtual ~ImportOptionsKit();
40982 
40983  HPS::Type ObjectType() const { return HPS::Type::ImageImportOptionsKit; };
40984 
40987  void Set(ImportOptionsKit const & in_kit);
40988 
40991  void Show(ImportOptionsKit & out_kit) const;
40992 
40996  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
40997 
41000  bool Empty() const;
41001 
41005  bool Equals(ImportOptionsKit const & in_kit) const;
41006 
41010  bool operator==(ImportOptionsKit const & in_kit) const;
41011 
41015  bool operator!=(ImportOptionsKit const & in_kit) const;
41016 
41023  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
41024 
41028  ImportOptionsKit & SetFormat(Image::Format in_format);
41029 
41034  ImportOptionsKit & SetDownSampling(bool in_state);
41035 
41040  ImportOptionsKit & SetCompressionQuality(float in_quality);
41041 
41044  ImportOptionsKit & UnsetSize();
41045 
41048  ImportOptionsKit & UnsetFormat();
41049 
41052  ImportOptionsKit & UnsetDownSampling();
41053 
41056  ImportOptionsKit & UnsetCompressionQuality();
41057 
41060  ImportOptionsKit & UnsetEverything();
41061 
41066  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
41067 
41071  bool ShowFormat(Image::Format & out_format) const;
41072 
41076  bool ShowDownSampling(bool & out_state) const;
41077 
41081  bool ShowCompressionQuality(float & out_quality) const;
41082  };
41083 
41085  class HPS_API File
41086  {
41087  public:
41093  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
41094 
41101  static void Export(char const * in_file_name, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
41102 
41111  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);
41112 
41117  static void Export(char const * in_file_name, HPS::ImageKit const & in_image_kit);
41118 
41119  private:
41121  File();
41122  };
41123 
41124 private:
41126  Image();
41127 };
41128 
41129 
41131 class HPS_API ImageKit : public Kit
41132 {
41133 public:
41135  ImageKit();
41136 
41139  ImageKit(ImageKit const & in_kit);
41140 
41145  ImageKit(ImageKit const & in_kit, HPS::Image::Format in_format);
41146 
41150  ImageKit(ImageKit && in_that);
41151 
41155  ImageKit & operator=(ImageKit && in_that);
41156 
41157  virtual ~ImageKit();
41158 
41159  HPS::Type ObjectType() const { return HPS::Type::ImageKit; };
41160 
41163  void Set(ImageKit const & in_kit);
41164 
41167  void Show(ImageKit & out_kit) const;
41168 
41172  ImageKit & operator=(ImageKit const & in_kit);
41173 
41176  bool Empty() const;
41177 
41181  bool Equals(ImageKit const & in_kit) const;
41182 
41186  bool operator==(ImageKit const & in_kit) const;
41187 
41191  bool operator!=(ImageKit const & in_kit) const;
41192 
41196  void Convert(ImageKit const & in_kit, HPS::Image::Format in_format);
41197 
41200  void Convert(HPS::Image::Format in_format);
41201 
41206  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
41207 
41211  ImageKit & SetData(ByteArray const & in_image_data);
41212 
41217  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
41218 
41222  ImageKit & SetFormat(Image::Format in_format);
41223 
41227  ImageKit & SetDownSampling(bool in_state);
41228 
41232  ImageKit & SetCompressionQuality(float in_quality);
41233 
41236  ImageKit & UnsetSize();
41237 
41240  ImageKit & UnsetData();
41241 
41244  ImageKit & UnsetFormat();
41245 
41248  ImageKit & UnsetDownSampling();
41249 
41252  ImageKit & UnsetCompressionQuality();
41253 
41256  ImageKit & UnsetEverything();
41257 
41262  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
41263 
41267  bool ShowData(ByteArray & out_image_data) const;
41268 
41272  bool ShowFormat(Image::Format & out_format) const;
41273 
41277  bool ShowDownSampling(bool & out_state) const;
41278 
41282  bool ShowCompressionQuality(float & out_quality) const;
41283 };
41284 
41285 
41291 {
41292 public:
41296 
41301 
41306 
41311 
41313 
41314  virtual HPS::Type Type() const { return ObjectType(); }
41315 
41316  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowOptionsControl; };
41317 
41321  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
41322 
41327  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
41328 
41333  OffScreenWindowOptionsControl & SetNativeFormat(Window::ImageFormat in_format, float in_quality = 1.0f);
41334 
41337  OffScreenWindowOptionsControl & SetFallbackFonts(UTF8Array const & in_fonts);
41338 
41340  OffScreenWindowOptionsControl & UnsetFallbackFonts();
41341 
41344  size_t ShowFallbackFonts(UTF8Array & out_fonts) const;
41345 
41349  bool ShowDriver(Window::Driver & out_driver) const;
41350 
41355  OffScreenWindowOptionsControl & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
41356 
41361  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
41362 
41367  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
41368 
41373  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
41374 
41379  bool ShowImage(ByteArray & out_bytes) const;
41380 
41384  bool ShowHardwareResident(bool & out_state) const;
41385 
41390  bool ShowOpacity(bool & out_state, float & out_opacity) const;
41391 
41396  bool ShowNativeFormat(Window::ImageFormat & out_format, float & out_quality) const;
41397 
41401  bool ShowFramebufferRetention(bool & out_retain) const;
41402 
41403 
41404 private:
41407 };
41408 
41409 
41412 class HPS_API OffScreenWindowKey : public WindowKey
41413 {
41414 public:
41417 
41422  OffScreenWindowKey(Key const & in_key);
41423 
41426  OffScreenWindowKey(OffScreenWindowKey const & in_that);
41427 
41432 
41436  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
41437 
41438  ~OffScreenWindowKey();
41439 
41440  HPS::Type ObjectType() const { return HPS::Type::OffScreenWindowKey; };
41441 
41444  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
41445 
41448  OffScreenWindowOptionsControl GetWindowOptionsControl();
41449 
41453  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
41454 };
41455 
41456 
41457 
41458 
41460 class HPS_API ImageDefinition : public Definition
41461 {
41462 public:
41464  ImageDefinition();
41465 
41470  ImageDefinition(Definition const & in_that);
41471 
41474  ImageDefinition(ImageDefinition const & in_that);
41475 
41479  ImageDefinition & operator=(ImageDefinition const & in_that);
41480 
41484  ImageDefinition(ImageDefinition && in_that);
41485 
41489  ImageDefinition & operator=(ImageDefinition && in_that);
41490 
41491  ~ImageDefinition();
41492 
41493  HPS::Type ObjectType() const { return HPS::Type::ImageDefinition; };
41494 
41497  void Set(ImageKit const & in_kit);
41498 
41501  void Show(ImageKit & out_kit) const;
41502 };
41503 
41505 class HPS_API CubeMapDefinition : public Definition
41506 {
41507 public:
41510 
41515  CubeMapDefinition(Definition const & in_that);
41516 
41519  CubeMapDefinition(CubeMapDefinition const & in_that);
41520 
41524  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
41525 
41530 
41534  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
41535 
41536  ~CubeMapDefinition();
41537 
41538  HPS::Type ObjectType() const { return HPS::Type::CubeMapDefinition; };
41539 
41547  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
41548  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
41549  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
41550 
41558  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
41559  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
41560  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
41561 
41565  void ShowSource(ImageDefinitionArray & out_image_sources) const;
41566 
41569  void SetOptions(TextureOptionsKit const & in_options);
41570 
41573  void ShowOptions(TextureOptionsKit & out_options) const;
41574 };
41575 
41576 
41578 class HPS_API NamedStyleDefinition : public Definition
41579 {
41580 public:
41583 
41588  NamedStyleDefinition(Definition const & in_that);
41589 
41592  NamedStyleDefinition(NamedStyleDefinition const & in_that);
41593 
41597  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
41598 
41603 
41607  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
41608 
41610 
41611  HPS::Type ObjectType() const { return HPS::Type::NamedStyleDefinition; };
41612 
41616  SegmentKey GetSource() const;
41617 };
41618 
41619 
41622 {
41623 public:
41626 
41631  MaterialPaletteDefinition(Definition const & in_that);
41632 
41636 
41640  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
41641 
41646 
41650  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
41651 
41653 
41654  HPS::Type ObjectType() const { return HPS::Type::MaterialPaletteDefinition; };
41655 
41658  void Set(MaterialKitArray const & in_source);
41659 
41663  void Set(size_t in_count, MaterialKit const in_source []);
41664 
41667  void Show(MaterialKitArray & out_source) const;
41668 };
41669 
41670 
41671 
41673 class HPS_API LinePatternDefinition : public Definition
41674 {
41675 public:
41678 
41683  LinePatternDefinition(Definition const & in_that);
41684 
41688 
41692  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
41693 
41698 
41702  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
41703 
41705 
41706  HPS::Type ObjectType() const { return HPS::Type::LinePatternDefinition; };
41707 
41710  void Set(LinePatternKit const & in_kit);
41711 
41714  void Show(LinePatternKit & out_kit) const;
41715 };
41716 
41717 
41718 
41720 class HPS_API Shader
41721 {
41722 public:
41725  enum class Parameterization : uint32_t
41726  {
41728  Cylinder,
41730  PhysicalReflection,
41732  Object,
41738  NaturalUV,
41740  ReflectionVector,
41742  SurfaceNormal,
41744  Sphere,
41746  UV,
41748  World
41749  };
41750 
41752 class HPS_API ImportOptionsKit : public Kit
41753  {
41754  public:
41756  ImportOptionsKit();
41757 
41760  ImportOptionsKit(ImportOptionsKit const & in_kit);
41761 
41765  ImportOptionsKit(ImportOptionsKit && in_that);
41766 
41770  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
41771 
41772  virtual ~ImportOptionsKit();
41773 
41774  HPS::Type ObjectType() const { return HPS::Type::ShaderImportOptionsKit; };
41775 
41778  void Set(ImportOptionsKit const & in_kit);
41779 
41782  void Show(ImportOptionsKit & out_kit) const;
41783 
41787  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
41788 
41791  bool Empty() const;
41792 
41796  bool Equals(ImportOptionsKit const & in_kit) const;
41797 
41801  bool operator==(ImportOptionsKit const & in_kit) const;
41802 
41806  bool operator!=(ImportOptionsKit const & in_kit) const;
41807 
41814  ImportOptionsKit & SetMultitexture(bool in_state);
41815 
41819  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
41820 
41824  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
41825 
41829  ImportOptionsKit & UnsetMultitexture();
41830 
41833  ImportOptionsKit & UnsetParameterizationSource();
41834 
41837  ImportOptionsKit & UnsetTransformMatrix();
41838 
41841  ImportOptionsKit & UnsetEverything();
41842 
41848  bool ShowMultitexture(bool & out_state) const;
41849 
41853  bool ShowParameterizationSource(Parameterization & out_source) const;
41854 
41858  bool ShowTransformMatrix(MatrixKit & out_transform) const;
41859  };
41860 
41862  class HPS_API File
41863  {
41864  public:
41870  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
41871 
41872  private:
41874  File();
41875  };
41876 
41877 private:
41879  Shader();
41880 };
41881 
41882 
41884 class HPS_API ShaderKit : public Kit
41885 {
41886 public:
41888  ShaderKit();
41889 
41892  ShaderKit(ShaderKit const & in_kit);
41893 
41897  ShaderKit(ShaderKit && in_that);
41898 
41902  ShaderKit & operator=(ShaderKit && in_that);
41903 
41904  virtual ~ShaderKit();
41905 
41906  HPS::Type ObjectType() const { return HPS::Type::ShaderKit; };
41907 
41910  void Set(ShaderKit const & in_kit);
41911 
41914  void Show(ShaderKit & out_kit) const;
41915 
41919  ShaderKit & operator=(ShaderKit const & in_kit);
41920 
41923  bool Empty() const;
41924 
41928  bool Equals(ShaderKit const & in_kit) const;
41929 
41933  bool operator==(ShaderKit const & in_kit) const;
41934 
41938  bool operator!=(ShaderKit const & in_kit) const;
41939 
41943  ShaderKit & SetSource(char const * in_source);
41944 
41951  ShaderKit & SetMultitexture(bool in_state);
41952 
41956  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
41957 
41961  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
41962 
41965  ShaderKit & UnsetSource();
41966 
41970  ShaderKit & UnsetMultitexture();
41971 
41974  ShaderKit & UnsetParameterizationSource();
41975 
41978  ShaderKit & UnsetTransformMatrix();
41979 
41982  ShaderKit & UnsetEverything();
41983 
41987  bool ShowSource(UTF8 & out_source) const;
41988 
41994  bool ShowMultitexture(bool & out_state) const;
41995 
41999  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
42000 
42004  bool ShowTransformMatrix(MatrixKit & out_transform) const;
42005 };
42006 
42007 
42009 class HPS_API ShaderDefinition : public Definition
42010 {
42011 public:
42013  ShaderDefinition();
42014 
42019  ShaderDefinition(Definition const & in_that);
42020 
42023  ShaderDefinition(ShaderDefinition const & in_that);
42024 
42028  ShaderDefinition & operator=(ShaderDefinition const & in_that);
42029 
42033  ShaderDefinition(ShaderDefinition && in_that);
42034 
42038  ShaderDefinition & operator=(ShaderDefinition && in_that);
42039 
42040  ~ShaderDefinition();
42041 
42042  HPS::Type ObjectType() const { return HPS::Type::ShaderDefinition; };
42043 
42046  void Set(ShaderKit const & in_kit);
42047 
42050  void Show(ShaderKit & out_kit) const;
42051 };
42052 
42054 class HPS_API ShapeKit : public Kit
42055 {
42056 public:
42058  ShapeKit();
42059 
42062  ShapeKit(ShapeKit const & in_kit);
42063 
42067  ShapeKit(ShapeKit && in_that);
42068 
42072  ShapeKit & operator=(ShapeKit && in_that);
42073 
42074  virtual ~ShapeKit();
42075 
42076  HPS::Type ObjectType() const { return HPS::Type::ShapeKit; };
42077 
42080  void Set(ShapeKit const & in_kit);
42081 
42084  void Show(ShapeKit & out_kit) const;
42085 
42089  ShapeKit & operator=(ShapeKit const & in_kit);
42090 
42093  bool Empty() const;
42094 
42098  bool Equals(ShapeKit const & in_kit) const;
42099 
42103  bool operator==(ShapeKit const & in_kit) const;
42104 
42108  bool operator!=(ShapeKit const & in_kit) const;
42109 
42113  static HPS::ShapeKit GetDefault(Shape::Default in_default_shape);
42114 
42118  ShapeKit & SetElements(ShapeElementArray const & in_def);
42119 
42124  ShapeKit & SetElements(size_t in_count, ShapeElement const in_def []);
42125 
42129  ShapeKit & SetElement(ShapeElement const & in_element);
42130 
42133  ShapeKit & UnsetElements();
42134 
42137  ShapeKit & UnsetEverything();
42138 
42142  bool ShowElements(ShapeElementArray & out_def) const;
42143 
42144 };
42145 
42147 class HPS_API ShapeDefinition : public Definition
42148 {
42149 public:
42151  ShapeDefinition();
42152 
42157  ShapeDefinition(Definition const & in_that);
42158 
42161  ShapeDefinition(ShapeDefinition const & in_that);
42162 
42166  ShapeDefinition & operator=(ShapeDefinition const & in_that);
42167 
42171  ShapeDefinition(ShapeDefinition && in_that);
42172 
42176  ShapeDefinition & operator=(ShapeDefinition && in_that);
42177 
42178  ~ShapeDefinition();
42179 
42180  HPS::Type ObjectType() const { return HPS::Type::ShapeDefinition; };
42181 
42184  void Set(ShapeKit const & in_kit);
42185 
42188  void Show(ShapeKit & out_kit) const;
42189 };
42190 
42191 
42195 class HPS_API CutGeometryGatheringOptionsKit : public Kit
42196 {
42197 public:
42200 
42204 
42209 
42214 
42215  virtual ~CutGeometryGatheringOptionsKit();
42216 
42217  HPS::Type ObjectType() const {return HPS::Type::CutGeometryGatheringOptionsKit;};
42218 
42222  static CutGeometryGatheringOptionsKit GetDefault();
42223 
42226  void Set(CutGeometryGatheringOptionsKit const & in_kit);
42227 
42230  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
42231 
42236 
42239  bool Empty() const;
42240 
42244  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
42245 
42249  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
42250 
42254  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
42255 
42256 
42260  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
42261 
42265  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
42266 
42271 
42272 
42275  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
42276 
42279  CutGeometryGatheringOptionsKit & UnsetOffset();
42280 
42283  CutGeometryGatheringOptionsKit & UnsetLevel();
42284 
42287  CutGeometryGatheringOptionsKit & UnsetEverything();
42288 
42289 
42293  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
42294 
42298  bool ShowOffset(size_t & out_offset) const;
42299 
42303  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
42304 };
42305 
42307 class HPS_API SearchOptionsKit : public Kit
42308 {
42309 public:
42311  SearchOptionsKit();
42312 
42315  SearchOptionsKit(SearchOptionsKit const & in_kit);
42316 
42320  SearchOptionsKit(SearchOptionsKit && in_that);
42321 
42325  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
42326 
42327  virtual ~SearchOptionsKit();
42328 
42329  HPS::Type ObjectType() const {return HPS::Type::SearchOptionsKit;};
42330 
42334  static SearchOptionsKit GetDefault();
42335 
42338  void Set(SearchOptionsKit const & in_kit);
42339 
42342  void Show(SearchOptionsKit & out_kit) const;
42343 
42347  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
42348 
42351  bool Empty() const;
42352 
42356  bool Equals(SearchOptionsKit const & in_kit) const;
42357 
42361  bool operator==(SearchOptionsKit const & in_kit) const;
42362 
42366  bool operator!=(SearchOptionsKit const & in_kit) const;
42367 
42371  SearchOptionsKit & SetCriteria(Search::Type in_request);
42372 
42376  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
42377 
42381  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
42382 
42387  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
42388 
42392  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
42393 
42396  SearchOptionsKit & UnsetBehavior();
42397 
42400  SearchOptionsKit & UnsetCriteria();
42401 
42404  SearchOptionsKit & UnsetSearchSpace();
42405 
42408  SearchOptionsKit & UnsetEverything();
42409 
42413  bool ShowBehavior(Search::Behavior & out_behavior) const;
42414 
42418  bool ShowCriteria(SearchTypeArray & out_types) const;
42419 
42423  bool ShowSearchSpace(Search::Space & out_search_space) const;
42424 };
42425 
42429 class HPS_API TreeContext : public Object
42430 {
42431 public:
42434  TreeContext(bool in_create = true);
42435 
42438  TreeContext(TreeContext const & in_that);
42439 
42443  TreeContext(TreeContext && in_that);
42444 
42448  TreeContext & operator=(TreeContext && in_that);
42449 
42451  virtual ~TreeContext();
42452 
42453  HPS::Type ObjectType() const {return HPS::Type::TreeContext;};
42454 
42458  TreeContext & operator=(TreeContext const & in_that);
42459 
42463  bool Equals(TreeContext const & in_that) const;
42464 
42468  bool operator==(TreeContext const & in_that) const;
42469 
42473  bool operator!=(TreeContext const & in_that) const;
42474 
42475 };
42476 
42478 class HPS_API SelectionOptionsKit : public Kit
42479 {
42480 public:
42483 
42486  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
42487 
42492 
42496  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
42497 
42498  virtual ~SelectionOptionsKit();
42499 
42500  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsKit;};
42501 
42505  static SelectionOptionsKit GetDefault();
42506 
42509  void Set(SelectionOptionsKit const & in_kit);
42510 
42513  void Show(SelectionOptionsKit & out_kit) const;
42514 
42518  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
42519 
42522  bool Empty() const;
42523 
42527  bool Equals(SelectionOptionsKit const & in_kit) const;
42528 
42532  bool operator==(SelectionOptionsKit const & in_kit) const;
42533 
42537  bool operator!=(SelectionOptionsKit const & in_kit) const;
42538 
42566  SelectionOptionsKit & SetProximity(float in_proximity);
42567 
42573  SelectionOptionsKit & SetLevel(Selection::Level in_level);
42574 
42580  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
42581 
42591  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
42592 
42600  SelectionOptionsKit & SetSorting(bool in_sorted);
42601 
42607  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
42608 
42614  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
42615 
42622  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment, bool in_scope_only = false);
42623 
42630  SelectionOptionsKit & SetScope(KeyPath const & in_start_path, bool in_scope_only = false);
42631 
42636  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
42637 
42644  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
42645 
42652  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
42653 
42660  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
42661 
42668  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
42669 
42673  SelectionOptionsKit & SetSelectability(HPS::SelectabilityKit const & in_selectability);
42674 
42679  SelectionOptionsKit & SetCondition(char const * in_condition);
42680 
42685  SelectionOptionsKit & SetConditions(UTF8Array const & in_conditions);
42686 
42691  SelectionOptionsKit & SetConditions(size_t in_count, UTF8 const in_conditions[]);
42692 
42694  SelectionOptionsKit & UnsetConditions();
42695 
42698  bool ShowConditions(UTF8Array & out_conditions) const;
42699 
42702  SelectionOptionsKit & UnsetSelectability();
42703 
42706  SelectionOptionsKit & UnsetProximity();
42707 
42710  SelectionOptionsKit & UnsetLevel();
42711 
42714  SelectionOptionsKit & UnsetInternalLimit();
42715 
42718  SelectionOptionsKit & UnsetRelatedLimit();
42719 
42722  SelectionOptionsKit & UnsetSorting();
42723 
42726  SelectionOptionsKit & UnsetAlgorithm();
42727 
42730  SelectionOptionsKit & UnsetGranularity();
42731 
42734  SelectionOptionsKit & UnsetScope();
42735 
42738  SelectionOptionsKit & UnsetTreeContext();
42739 
42742  SelectionOptionsKit & UnsetExtentCullingRespected();
42743 
42746  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
42747 
42750  SelectionOptionsKit & UnsetFrustumCullingRespected();
42751 
42754  SelectionOptionsKit & UnsetVectorCullingRespected();
42755 
42756 
42759  SelectionOptionsKit & UnsetEverything();
42760 
42764  bool ShowProximity(float & out_proximity) const;
42765 
42769  bool ShowLevel(Selection::Level & out_level) const;
42770 
42774  bool ShowInternalLimit(size_t & out_limit) const;
42775 
42779  bool ShowRelatedLimit(size_t & out_limit) const;
42780 
42784  bool ShowSorting(bool & out_sorted) const;
42785 
42789  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
42790 
42794  bool ShowGranularity(Selection::Granularity & out_granularity) const;
42795 
42801  bool ShowScope(KeyPath & out_start_path, bool & out_scope_only) const;
42802 
42806  bool ShowTreeContext(TreeContext & out_tree_context) const;
42807 
42811  bool ShowExtentCullingRespected(bool & out_state) const;
42812 
42816  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
42817 
42821  bool ShowFrustumCullingRespected(bool & out_state) const;
42822 
42826  bool ShowVectorCullingRespected(bool & out_state) const;
42827 
42831  bool ShowSelectability(HPS::SelectabilityKit & out_selectability) const;
42832 };
42833 
42834 
42835 
42839 class HPS_API SelectionOptionsControl : public Control
42840 {
42841 public:
42844  explicit SelectionOptionsControl(WindowKey const & in_window);
42845 
42849 
42854 
42858  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
42859 
42861 
42862  virtual HPS::Type Type() const { return ObjectType(); }
42863 
42864  HPS::Type ObjectType() const {return HPS::Type::SelectionOptionsControl;};
42865 
42869  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
42870 
42898  SelectionOptionsControl & SetProximity(float in_proximity);
42899 
42905  SelectionOptionsControl & SetLevel(Selection::Level in_level);
42906 
42913  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
42914 
42923  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
42924 
42932  SelectionOptionsControl & SetSorting(bool in_sorted);
42933 
42939  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
42940 
42946  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
42947 
42954  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
42955 
42962  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
42963 
42970  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
42971 
42978  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
42979 
42980 
42984  SelectionOptionsControl & UnsetProximity();
42985 
42989  SelectionOptionsControl & UnsetLevel();
42990 
42994  SelectionOptionsControl & UnsetInternalLimit();
42995 
42999  SelectionOptionsControl & UnsetRelatedLimit();
43000 
43004  SelectionOptionsControl & UnsetSorting();
43005 
43009  SelectionOptionsControl & UnsetAlgorithm();
43010 
43014  SelectionOptionsControl & UnsetGranularity();
43015 
43019  SelectionOptionsControl & UnsetExtentCullingRespected();
43020 
43024  SelectionOptionsControl & UnsetDeferralExtentCullingRespected();
43025 
43029  SelectionOptionsControl & UnsetFrustumCullingRespected();
43030 
43034  SelectionOptionsControl & UnsetVectorCullingRespected();
43035 
43039  SelectionOptionsControl & UnsetEverything();
43040 
43044  bool ShowProximity(float & out_proximity) const;
43045 
43049  bool ShowLevel(Selection::Level & out_level) const;
43050 
43054  bool ShowInternalLimit(size_t & out_limit) const;
43055 
43059  bool ShowRelatedLimit(size_t & out_limit) const;
43060 
43064  bool ShowSorting(bool & out_sorted) const;
43065 
43069  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
43070 
43074  bool ShowGranularity(Selection::Granularity & out_granularity) const;
43075 
43079  bool ShowExtentCullingRespected(bool & out_state) const;
43080 
43084  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
43085 
43089  bool ShowFrustumCullingRespected(bool & out_state) const;
43090 
43094  bool ShowVectorCullingRespected(bool & out_state) const;
43095 
43096 private:
43099 };
43100 
43101 
43102 
43104 class HPS_API SelectionItem : public Object
43105 {
43106 public:
43108  SelectionItem();
43109 
43112  SelectionItem(SelectionItem const & in_that);
43113 
43117  SelectionItem(SelectionItem && in_that);
43118 
43122  SelectionItem & operator=(SelectionItem && in_that);
43123 
43124  virtual ~SelectionItem();
43125 
43126  HPS::Type ObjectType() const {return HPS::Type::SelectionItem;};
43127 
43130  void Set(SelectionItem const & in_that);
43131 
43135  SelectionItem & operator=(SelectionItem const & in_that);
43136 
43140  bool Equals(SelectionItem const & in_that) const;
43141 
43145  bool operator==(SelectionItem const & in_that) const;
43146 
43150  bool operator!=(SelectionItem const & in_that) const;
43151 
43155  bool ShowSelectionLevel(Selection::Level & out_level) const;
43156 
43160  bool ShowSelectedItem(Key & out_selection) const;
43161 
43165  bool ShowPath(KeyPath & out_path) const;
43166 
43170  bool ShowFaces(SizeTArray & out_faces) const;
43171 
43175  bool ShowVertices(SizeTArray & out_vertices) const;
43176 
43181  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
43182 
43186  bool ShowCharacters(SizeTArray & out_characters) const;
43187 
43191  bool ShowSelectionPosition(WindowPoint & out_location) const;
43192 
43196  bool ShowSelectionPosition(WorldPoint & out_location) const;
43197 
43201  bool ShowNormalizedSelectionPosition(WindowPoint & out_location) const;
43202 
43203 };
43204 
43206 class HPS_API SelectionResultsIterator : public Object
43207 {
43208 public:
43211 
43216 
43221 
43225  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
43226 
43228 
43229  HPS::Type ObjectType() const {return HPS::Type::SelectionResultsIterator;}
43230 
43234  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
43235 
43238  void Set(SelectionResultsIterator const & in_that);
43239 
43241  void Next();
43242 
43245  SelectionResultsIterator & operator++();
43246 
43249  SelectionResultsIterator operator++(int in_val);
43250 
43253  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
43254 
43257  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
43258 
43259 
43262  bool IsValid() const;
43263 
43265  void Reset();
43266 
43269  SelectionItem GetItem() const;
43270 
43273  SelectionItem operator*() const;
43274 
43275 
43276 };
43277 
43281 class HPS_API SelectionResults : public Object
43282 {
43283 public:
43285  SelectionResults();
43286 
43289  SelectionResults(SelectionResults const & in_that);
43290 
43294  SelectionResults(SelectionResults && in_that);
43295 
43299  SelectionResults & operator=(SelectionResults && in_that);
43300 
43301  ~SelectionResults();
43302 
43303  HPS::Type ObjectType() const {return HPS::Type::SelectionResults;}
43304 
43307  void Assign(SelectionResults const & in_that);
43308 
43312  SelectionResults & operator=(SelectionResults const & in_that);
43313 
43317  bool Equals(SelectionResults const & in_that) const;
43318 
43322  bool operator==(SelectionResults const & in_that) const;
43323 
43327  bool operator!=(SelectionResults const & in_that) const;
43328 
43330  virtual void Reset();
43331 
43334  Selection::Level GetSelectionLevel() const;
43335 
43338  size_t GetCount() const;
43339 
43342  SelectionResultsIterator GetIterator() const;
43343 
43349  bool Union(SelectionResults const & in_that);
43350 
43355  bool Intersect(SelectionResults const & in_that);
43356 
43362  bool SymmetricDifference(SelectionResults const & in_that);
43363 
43368  bool Difference(SelectionResults const & in_that);
43369 
43372  void Copy(SelectionResults const & in_that);
43373 };
43374 
43377 class HPS_API SelectionControl : public Control
43378 {
43379 public:
43382  explicit SelectionControl(WindowKey const & in_window);
43383 
43386  SelectionControl(SelectionControl const & in_that);
43387 
43391  SelectionControl(SelectionControl && in_that);
43392 
43396  SelectionControl & operator=(SelectionControl && in_that);
43397 
43398  ~SelectionControl();
43399 
43400  HPS::Type ObjectType() const {return HPS::Type::SelectionControl;};
43401 
43405  SelectionControl & operator=(SelectionControl const & in_that);
43406 
43412  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
43413 
43418  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
43419 
43425  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
43426 
43431  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
43432 
43438  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
43439 
43444  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
43445 
43452  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
43453 
43459  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
43460 
43466  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
43467 
43472  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
43473 
43480  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
43481 
43487  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
43488 
43489 
43490  //Object space selections
43491 
43497  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
43498 
43503  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
43504 
43510  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
43511 
43516  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
43517 
43518 
43525  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
43526 
43532  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
43533 
43534 
43541  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
43542 
43548  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
43549 
43550 private:
43552  SelectionControl();
43553 };
43554 
43555 
43556 
43558 class HPS_API HighlightOptionsKit : public Kit
43559 {
43560 public:
43563 
43566  HighlightOptionsKit(char const * in_style_name);
43567 
43571  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
43572 
43575  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
43576 
43581 
43585  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
43586 
43587  virtual ~HighlightOptionsKit();
43588 
43589  HPS::Type ObjectType() const {return HPS::Type::HighlightOptionsKit;};
43590 
43594  static HighlightOptionsKit GetDefault();
43595 
43598  void Set(HighlightOptionsKit const & in_kit);
43599 
43602  void Show(HighlightOptionsKit & out_kit) const;
43603 
43607  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
43608 
43611  bool Empty() const;
43612 
43616  bool Equals(HighlightOptionsKit const & in_kit) const;
43617 
43621  bool operator==(HighlightOptionsKit const & in_kit) const;
43622 
43626  bool operator!=(HighlightOptionsKit const & in_kit) const;
43627 
43628 
43632  HighlightOptionsKit & SetStyleName(char const * in_style_name);
43633 
43637  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
43638 
43646  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
43647 
43653  HighlightOptionsKit & SetNotification(bool in_state);
43654 
43658  HighlightOptionsKit & SetSubentityHighlighting(bool in_enable);
43659 
43662  HighlightOptionsKit & UnsetStyleName();
43663 
43666  HighlightOptionsKit & UnsetSecondaryStyleName();
43667 
43670  HighlightOptionsKit & UnsetOverlay();
43671 
43674  HighlightOptionsKit & UnsetNotification();
43675 
43678  HighlightOptionsKit & UnsetSubentityHighlighting();
43679 
43682  HighlightOptionsKit & UnsetEverything();
43683 
43684 
43688  bool ShowStyleName(UTF8 & out_style_name) const;
43689 
43693  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
43694 
43698  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
43699 
43703  bool ShowNotification(bool & out_state) const;
43704 
43708  bool ShowSubentityHighlighting(bool & out_enable) const;
43709 };
43710 
43713 class HPS_API HighlightControl : public Control
43714 {
43715 public:
43718  explicit HighlightControl(WindowKey const & in_window);
43719 
43722  HighlightControl(HighlightControl const & in_that);
43723 
43727  HighlightControl(HighlightControl && in_that);
43728 
43732  HighlightControl & operator=(HighlightControl && in_that);
43733 
43734  ~HighlightControl();
43735 
43736  virtual HPS::Type Type() const { return ObjectType(); }
43737 
43738  HPS::Type ObjectType() const {return HPS::Type::HighlightControl;};
43739 
43743  HighlightControl & operator=(HighlightControl const & in_that);
43744 
43749  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
43750 
43755  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
43756 
43761  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
43762 
43767  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
43768 
43773  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
43774 
43783  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);
43784 
43793  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);
43794 
43806  HighlightControl & Highlight(
43807  KeyPath const & in_item,
43808  HighlightOptionsKit const & in_options,
43809  size_t in_vertices_count,
43810  size_t const in_vertices[],
43811  size_t in_edges_count,
43812  size_t const in_edges1[],
43813  size_t const in_edges2[],
43814  size_t in_faces_count,
43815  size_t const in_faces[]);
43816 
43828  HighlightControl & Highlight(
43829  Key const & in_item,
43830  HighlightOptionsKit const & in_options,
43831  size_t in_vertices_count,
43832  size_t const in_vertices[],
43833  size_t in_edges_count,
43834  size_t const in_edges1[],
43835  size_t const in_edges2[],
43836  size_t in_faces_count,
43837  size_t const in_faces[]);
43838 
43843  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
43844 
43849  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
43850 
43855  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
43856 
43861  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
43862 
43867  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
43868 
43877  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);
43878 
43887  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);
43888 
43900  HighlightControl & Unhighlight(
43901  KeyPath const & in_item,
43902  HighlightOptionsKit const & in_options,
43903  size_t in_vertices_count,
43904  size_t const in_vertices[],
43905  size_t in_edges_count,
43906  size_t const in_edges1[],
43907  size_t const in_edges2[],
43908  size_t in_faces_count,
43909  size_t const in_faces[]);
43910 
43922  HighlightControl & Unhighlight(
43923  Key const & in_item,
43924  HighlightOptionsKit const & in_options,
43925  size_t in_vertices_count,
43926  size_t const in_vertices[],
43927  size_t in_edges_count,
43928  size_t const in_edges1[],
43929  size_t const in_edges2[],
43930  size_t in_faces_count,
43931  size_t const in_faces[]);
43932 
43936  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
43937 
43940  HighlightControl & UnhighlightEverything();
43941 
43942 private:
43944  HighlightControl();
43945 };
43946 
43948 class HPS_API UpdateOptionsKit : public Kit
43949 {
43950 public:
43952  UpdateOptionsKit();
43953 
43956  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
43957 
43961  UpdateOptionsKit(UpdateOptionsKit && in_that);
43962 
43966  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
43967 
43968  virtual ~UpdateOptionsKit();
43969 
43970  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsKit;};
43971 
43975  static UpdateOptionsKit GetDefault();
43976 
43979  void Set(UpdateOptionsKit const & in_kit);
43980 
43983  void Show(UpdateOptionsKit & out_kit) const;
43984 
43988  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
43989 
43992  bool Empty() const;
43993 
43997  bool Equals(UpdateOptionsKit const & in_kit) const;
43998 
44002  bool operator==(UpdateOptionsKit const & in_kit) const;
44003 
44007  bool operator!=(UpdateOptionsKit const & in_kit) const;
44008 
44012  UpdateOptionsKit & SetUpdateType(HPS::Window::UpdateType in_type);
44013 
44017  UpdateOptionsKit & SetTimeLimit(HPS::Time in_time_limit);
44018 
44021  UpdateOptionsKit & UnsetUpdateType();
44022 
44025  UpdateOptionsKit & UnsetTimeLimit();
44026 
44029  UpdateOptionsKit & UnsetEverything();
44030 
44031 
44035  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
44036 
44040  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
44041 
44042 };
44043 
44044 
44045 
44051 class HPS_API UpdateOptionsControl : public Control
44052 {
44053 public:
44056  explicit UpdateOptionsControl(WindowKey const & in_window);
44057 
44060  UpdateOptionsControl(UpdateOptionsControl const & in_that);
44061 
44066 
44070  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
44071 
44073 
44074  virtual HPS::Type Type() const { return ObjectType(); }
44075 
44076  HPS::Type ObjectType() const {return HPS::Type::UpdateOptionsControl;};
44077 
44081  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
44082 
44086  UpdateOptionsControl & SetUpdateType(HPS::Window::UpdateType in_type);
44087 
44091  UpdateOptionsControl & SetTimeLimit(HPS::Time in_time_limit);
44092 
44096  UpdateOptionsControl & UnsetUpdateType();
44097 
44101  UpdateOptionsControl & UnsetTimeLimit();
44102 
44106  UpdateOptionsControl & UnsetEverything();
44107 
44111  bool ShowUpdateType(HPS::Window::UpdateType & out_type) const;
44112 
44116  bool ShowTimeLimit(HPS::Time & out_time_limit) const;
44117 
44118 private:
44121 };
44122 
44125 class HPS_API World : public Object
44126 {
44127 public:
44134  World(char const * in_license, char const * in_code_generation_directory = nullptr);
44135 
44137  ~World();
44138 
44139  HPS::Type ObjectType() const {return HPS::Type::World;};
44140 
44145  World & SetMaterialLibraryDirectory(char const * in_directory);
44146 
44151  World & SetFontDirectory(char const * in_directory);
44152 
44158  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
44159 
44164  World & SetFontDirectories(UTF8Array const & in_directories);
44165 
44171  World & SetDriverConfigFile(char const * in_filename);
44172 
44178  World & SetExchangeLibraryDirectory(char const * in_directory);
44179 
44185  World & SetPublishResourceDirectory(char const * in_directory);
44186 
44192  World & SetParasolidSchemaDirectory(char const * in_directory);
44193 
44198  World & SetRealDWGDirectory(char const * in_directory);
44199 
44205  World & SetRealDWGDirectory(char const * in_directory, UTF8Array const & in_object_enabler_directories);
44206 
44212  World & SetParasolidBodyshopDirectory(char const * in_directory);
44213 
44216  World & UnsetMaterialLibraryDirectory();
44217 
44220  World & UnsetFontDirectories();
44221 
44224  World & UnsetDriverConfigFile();
44225 
44228  World & UnsetExchangeLibraryDirectory();
44229 
44232  World & UnsetPublishResourceDirectory();
44233 
44236  World & UnsetParasolidSchemaDirectory();
44237 
44240  World & UnsetRealDWGDirectory();
44241 
44244  World & UnsetParasolidBodyshopDirectory();
44245 
44249  bool ShowLicense(UTF8 & out_license) const;
44250 
44254  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
44255 
44259  bool ShowFontDirectories(UTF8Array & out_directories) const;
44260 
44264  bool ShowDriverConfigFile(UTF8 & out_filename) const;
44265 
44269  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
44270 
44274  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
44275 
44279  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
44280 
44285  bool ShowRealDWGDirectory(UTF8 & out_directory, UTF8Array & out_object_enabler_directories) const;
44286 
44290  bool ShowParasolidBodyshopDirectory(UTF8 & out_directory) const;
44291 
44295  static void AddCodeGenerationComment(UTF8 const & in_comment);
44296 
44298  static void StopCodeGeneration();
44299 
44300 private:
44302  World();
44303 
44305  virtual void Reset() {}
44306 };
44307 
44308 
44324 class HPS_API EmergencyHandler
44325 {
44326 public:
44327 
44330 
44331  virtual ~EmergencyHandler();
44332 
44334  intptr_t GetClassID() const;
44335 
44339  virtual void Handle(char const * message, HPS::Emergency::Code code) = 0;
44340 
44341  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
44342  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
44343 };
44344 
44345 
44348 class HPS_API Database
44349 {
44350 public:
44355  static void Execute(bool in_once=true);
44356 
44359  static Time GetTime();
44360 
44362  static void Sleep(Time milliseconds);
44363 
44388  static void RelinquishMemory();
44389 
44390 
44416  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
44417 
44425  static void Reset();
44426 
44428  static void Synchronize();
44429 
44432  static WindowKeyArray GetWindowKeys();
44433 
44436  static SegmentKeyArray GetRootSegments();
44437 
44440  static PortfolioKeyArray GetPortfolios();
44441 
44446  static PortfolioKey const GetMaterialLibraryPortfolio();
44447 
44453  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
44454 
44459  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
44460 
44464  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
44465 
44469  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
44470 
44477  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
44478 
44484  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
44485 
44491  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
44492 
44497  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
44498 
44501  static SegmentKey CreateRootSegment();
44502 
44505  static PortfolioKey CreatePortfolio();
44506 
44509  static EventDispatcher CreateEventDispatcher();
44510 
44514  static EventDispatcher CreateEventDispatcher(char const * in_name);
44515 
44521  static size_t SelectByShell(ShellKit const & in_shell,
44522  SelectionOptionsKit const & in_options,
44523  SelectionResults & out_results);
44524 
44530  static size_t SelectByShell(ShellKey const & in_shell,
44531  SelectionOptionsKit const & in_options,
44532  SelectionResults & out_results);
44533 
44540  static size_t SelectByVolume(SimpleCuboid const & in_volume,
44541  SelectionOptionsKit const & in_options,
44542  SelectionResults & out_results);
44543 
44550  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
44551  SelectionOptionsKit const & in_options,
44552  SelectionResults & out_results);
44553 
44556  static EventDispatcher const & GetEventDispatcher();
44557 
44558 
44562  static bool GetInformationEventFilter(HPS::Info::Code in_code);
44563 
44567  static bool GetWarningEventFilter(HPS::Info::Code in_code);
44568 
44572  static bool GetErrorEventFilter(HPS::Info::Code in_code);
44573 
44578  static bool SetInformationEventFilter(HPS::Info::Code in_code, bool in_filtered);
44579 
44584  static bool SetWarningEventFilter(HPS::Info::Code in_code, bool in_filtered);
44585 
44590  static bool SetErrorEventFilter(HPS::Info::Code in_code, bool in_filtered);
44591 
44592 
44595  static void SetEmergencyHandler(HPS::EmergencyHandler const & in_emergency_handler);
44596 
44598  static void UnsetEmergencyHandler();
44599 
44602  static size_t GetSoftMemoryLimit();
44603 
44607  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
44608 
44611  static size_t GetOOCMemoryLimit();
44612 
44616  static size_t SetOOCMemoryLimit(size_t in_limit_bytes);
44617 
44621  static bool IsDriverAvailable(HPS::Window::Driver in_driver);
44622 
44623 private:
44625  Database();
44626 };
44627 
44628 
44632 
44633 
44634 
44636 class HPS_API EventDispatcher : public Object
44637 {
44638 public:
44641  EventDispatcher();
44642 
44645  EventDispatcher(EventDispatcher const & in_that);
44646 
44650  EventDispatcher(EventDispatcher && in_that);
44651 
44655  EventDispatcher & operator=(EventDispatcher && in_that);
44656 
44657  virtual ~EventDispatcher();
44658 
44659  HPS::Type ObjectType() const {return HPS::Type::EventDispatcher;};
44660 
44664  EventDispatcher & operator=(EventDispatcher const & in_that);
44665 
44669  bool Equals(EventDispatcher const & in_that) const;
44670 
44674  bool operator==(EventDispatcher const & in_that) const;
44675 
44679  bool operator!=(EventDispatcher const & in_that) const;
44680 
44685  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
44686 
44691  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
44692 
44697  bool UnSubscribe(EventHandler const & in_handler) const;
44698 
44702  bool UnSubscribe(intptr_t in_type) const;
44703 
44707  bool InjectEvent(Event const & in_event) const;
44708 
44713  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
44714 
44717  void Shutdown() const;
44718 
44721  bool IsShutdown() const;
44722 
44723 
44726  void SetName(char const * in_name) const;
44727 
44730  void ShowName(UTF8 & out_name) const;
44731 
44732 private:
44734  virtual void Reset() {}
44735 };
44736 
44737 
44740 class HPS_API EventHandler : public Object
44741 {
44742 public:
44744  EventHandler();
44745 
44748  EventHandler(EventHandler const & in_that);
44749 
44753  EventHandler(EventHandler && in_that);
44754 
44758  EventHandler & operator=(EventHandler && in_that);
44759 
44763  EventHandler & operator=(EventHandler const & in_that);
44764 
44765  virtual ~EventHandler();
44766 
44767  HPS::Type ObjectType() const {return HPS::Type::EventHandler;};
44768 
44773  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
44774 
44779  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
44780 
44784  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
44785 
44787  void UnSubscribeEverything() const;
44788 
44790  virtual void Reset() { UnSubscribeEverything(); }
44791 
44794  void Shutdown();
44795 
44798  enum class HandleResult : uint32_t
44799  {
44800  Handled,
44801  NotHandled
44802  };
44803 
44808  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
44809 };
44810 
44811 
44812 
44814 class HPS_API TimerTickEvent : public Event
44815 {
44816 public:
44819  {
44820  channel = GetClassID();
44821  consumable = false;
44822  }
44823 
44824 
44827  TimerTickEvent(Event const & in_event) : Event(in_event)
44828  {
44829  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
44830  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
44831  }
44832 
44833  ~TimerTickEvent();
44834 
44837  Event * Clone() const
44838  {
44839  TimerTickEvent * new_event = new TimerTickEvent(*this);
44840  return new_event;
44841  }
44842 
44846  virtual bool Drop(Event const * in_that_event) const
44847  {
44848  HPS_UNREFERENCED(in_that_event);
44849  return true;
44850  }
44851 
44852  virtual intptr_t Freshen() const {
44853  return GetClassID();
44854  }
44855 };
44856 
44858 class HPS_API HighlightEvent : public Event
44859 {
44860 public:
44861  enum class Action : uint32_t
44862  {
44863  None = 0,
44864  Highlight,
44865  Unhighlight,
44866  };
44867 
44870  {
44871  channel = GetClassID();
44872  consumable = false;
44873  action = Action::None;
44874  }
44875 
44876  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
44877  : Event(), action(in_action), results(in_results), options(in_options)
44878  {
44879  channel = GetClassID();
44880  consumable = false;
44881  }
44882 
44885  HighlightEvent(Event const & in_event) : Event(in_event)
44886  {
44887  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
44888  {
44889  auto that = static_cast<HighlightEvent const &>(in_event);
44890  action = that.action;
44891  results = that.results;
44892  options = that.options;
44893  }
44894  else
44895  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
44896  }
44897 
44898  ~HighlightEvent();
44899 
44902  Event * Clone() const
44903  {
44904  HighlightEvent * new_event = new HighlightEvent(*this);
44905  return new_event;
44906  }
44907 
44908  Action action;
44909  SelectionResults results;
44910  HighlightOptionsKit options;
44911 };
44912 
44914 class HPS_API InformationEvent : public Event
44915 {
44916 public:
44918  InformationEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
44919 
44922  InformationEvent(char const * in_message);
44923 
44927  InformationEvent(char const * in_message, HPS::Info::Code in_code);
44928 
44931  InformationEvent(Event const & in_event) : Event(in_event)
44932  {
44933  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
44934  {
44935  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
44936  message = event->message;
44937  code = event->code;
44938  }
44939  else
44940  {
44941  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
44942  }
44943  }
44944 
44945  ~InformationEvent();
44946 
44949  Event * Clone() const
44950  {
44951  InformationEvent * new_event = new InformationEvent(*this);
44952  return new_event;
44953  }
44954 
44958  virtual bool Equals(InformationEvent const & in_that) const
44959  {
44960  return message == in_that.message && code == in_that.code;
44961  }
44962 
44966  virtual bool operator== (InformationEvent const & in_that) const
44967  {
44968  return Equals(in_that);
44969  }
44970 
44974  virtual bool operator!= (InformationEvent const & in_that) const
44975  {
44976  return !Equals(in_that);
44977  }
44978 
44981 };
44982 
44983 
44985 class HPS_API WarningEvent : public Event
44986 {
44987 public:
44989  WarningEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
44990 
44993  WarningEvent(char const * in_message);
44994 
44998  WarningEvent(char const * in_message, HPS::Info::Code in_code);
44999 
45002  WarningEvent(Event const & in_event) : Event(in_event)
45003  {
45004  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
45005  {
45006  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
45007  message = event->message;
45008  code = event->code;
45009  }
45010  else
45011  {
45012  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45013  }
45014  }
45015 
45016  ~WarningEvent();
45017 
45020  Event * Clone() const
45021  {
45022  WarningEvent * new_event = new WarningEvent(*this);
45023  return new_event;
45024  }
45025 
45029  virtual bool Equals(WarningEvent const & in_that) const
45030  {
45031  return message == in_that.message && code == in_that.code;
45032  }
45033 
45037  virtual bool operator== (WarningEvent const & in_that) const
45038  {
45039  return Equals(in_that);
45040  }
45041 
45045  virtual bool operator!= (WarningEvent const & in_that) const
45046  {
45047  return !Equals(in_that);
45048  }
45049 
45052 };
45053 
45054 
45056 class HPS_API ErrorEvent : public Event
45057 {
45058 public:
45060  ErrorEvent() : Event(), code(HPS::Info::Code::Unknown) { channel = GetClassID(); }
45061 
45064  ErrorEvent(char const * in_message);
45065 
45069  ErrorEvent(char const * in_message, HPS::Info::Code in_code);
45070 
45073  ErrorEvent(Event const & in_event) : Event(in_event)
45074  {
45075  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
45076  {
45077  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
45078  message = event->message;
45079  code = event->code;
45080  }
45081  else
45082  {
45083  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45084  }
45085  }
45086 
45087  ~ErrorEvent();
45088 
45091  Event * Clone() const
45092  {
45093  ErrorEvent * new_event = new ErrorEvent(*this);
45094  return new_event;
45095  }
45096 
45100  virtual bool Equals(ErrorEvent const & in_that) const
45101  {
45102  return message == in_that.message && code == in_that.code;
45103  }
45104 
45108  virtual bool operator== (ErrorEvent const & in_that) const
45109  {
45110  return Equals(in_that);
45111  }
45112 
45116  virtual bool operator!= (ErrorEvent const & in_that) const
45117  {
45118  return !Equals(in_that);
45119  }
45120 
45123 };
45124 
45125 
45127 class HPS_API StandAloneWindowEvent : public Event
45128 {
45129 public:
45130 
45133  enum class Action : uint32_t
45134  {
45135  Unknown,
45136  Close,
45137  FocusIn,
45138  FocusOut,
45139  };
45140 
45142  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
45143 
45144 
45147  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
45148 
45151  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
45152  {
45153  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
45154  {
45155  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
45156  action = event->action;
45157  }
45158  else
45159  {
45160  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45161  }
45162  }
45163 
45165 
45168  Event * Clone() const
45169  {
45170  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
45171  return new_event;
45172  }
45173 
45177  virtual bool Equals(StandAloneWindowEvent const & in_that) const
45178  {
45179  return action == in_that.action;
45180  }
45181 
45185  virtual bool operator== (StandAloneWindowEvent const & in_that) const
45186  {
45187  return Equals(in_that);
45188  }
45189 
45193  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
45194  {
45195  return !Equals(in_that);
45196  }
45197 
45199 };
45200 
45202 class HPS_API FocusLostEvent : public Event
45203 {
45204 public:
45207  Event()
45208  { channel = GetClassID(); }
45209 
45210  ~FocusLostEvent();
45211 
45214  Event * Clone() const
45215  {
45216  FocusLostEvent * new_event = new FocusLostEvent(*this);
45217  return new_event;
45218  }
45219 };
45220 
45222 class HPS_API TextInputEvent : public Event
45223 {
45224  public:
45227  Event()
45228  { channel = GetClassID(); }
45229 
45232  TextInputEvent(char const * in_text) : Event(), text(in_text, "utf8") { channel = GetClassID(); }
45233 
45236  TextInputEvent(Event const & in_event) : Event(in_event)
45237  {
45238  if(in_event.GetChannel() == Object::ClassID<TextInputEvent>())
45239  {
45240  TextInputEvent const * event = static_cast<TextInputEvent const *>(&in_event);
45241  text = event->text;
45242  }
45243  else
45244  {
45245  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45246  }
45247  }
45248 
45252  virtual bool Equals(TextInputEvent const & in_that) const
45253  {
45254  return text == in_that.text;
45255  }
45256 
45260  virtual bool operator== (TextInputEvent const & in_that) const
45261  {
45262  return Equals(in_that);
45263  }
45264 
45268  virtual bool operator!= (ErrorEvent const & in_that) const
45269  {
45270  return !Equals(in_that);
45271  }
45272 
45273  ~TextInputEvent();
45274 
45277  Event * Clone() const
45278  {
45279  TextInputEvent * new_event = new TextInputEvent(*this);
45280  return new_event;
45281  }
45282 
45284 };
45285 
45286 
45288 class HPS_API UpdateCompletedEvent : public Event
45289 {
45290 public:
45292  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
45293 
45295  UpdateCompletedEvent(Time in_update_time, Window::UpdateStatus in_update_status) : Event(), update_time(in_update_time), update_status(in_update_status) { channel = GetClassID(); }
45296 
45299  UpdateCompletedEvent(Event const & in_event) : Event(in_event)
45300  {
45301  if(in_event.GetChannel() == Object::ClassID<UpdateCompletedEvent>())
45302  {
45303  UpdateCompletedEvent const * event = static_cast<UpdateCompletedEvent const *>(&in_event);
45304  update_time = event->update_time;
45305  update_status = event->update_status;
45306  }
45307  else
45308  {
45309  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45310  }
45311  }
45312 
45313  virtual ~UpdateCompletedEvent();
45314 
45317  Event * Clone() const
45318  {
45319  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
45320  return new_event;
45321  }
45322 
45323  Time update_time;
45324  Window::UpdateStatus update_status;
45325 };
45326 
45328 class HPS_API ImportStatusEvent : public Event
45329 {
45330 public:
45333  : Event()
45334  { channel = GetClassID(); }
45335 
45336  ImportStatusEvent(char const * in_message)
45337  : Event()
45338  , import_status_message(in_message, "utf8")
45339  { channel = GetClassID(); }
45340 
45343  ImportStatusEvent(Event const & in_event) : Event(in_event)
45344  {
45345  if (in_event.GetChannel() == Object::ClassID<ImportStatusEvent>())
45346  {
45347  auto event = static_cast<ImportStatusEvent const &>(in_event);
45348  import_status_message = event.import_status_message;
45349  }
45350  else
45351  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45352  }
45353 
45354  ~ImportStatusEvent();
45355 
45358  Event * Clone() const
45359  {
45360  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
45361  return new_event;
45362  }
45363 
45364  HPS::UTF8 import_status_message;
45365 };
45366 
45368 class HPS_API ShowKeyboardEvent : public Event
45369 {
45370 public:
45373  : Event()
45374  { channel = GetClassID(); }
45375 
45378  ShowKeyboardEvent(Event const & in_event) : Event(in_event)
45379  {
45380  if (in_event.GetChannel() != Object::ClassID<ShowKeyboardEvent>())
45381  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45382  }
45383 
45384  ~ShowKeyboardEvent();
45385 
45388  Event * Clone() const
45389  {
45390  ShowKeyboardEvent * new_event = new ShowKeyboardEvent(*this);
45391  return new_event;
45392  }
45393 
45394 };
45395 
45397 class HPS_API HideKeyboardEvent : public Event
45398 {
45399 public:
45402  : Event()
45403  { channel = GetClassID(); }
45404 
45407  HideKeyboardEvent(Event const & in_event) : Event(in_event)
45408  {
45409  if (in_event.GetChannel() != Object::ClassID<HideKeyboardEvent>())
45410  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
45411  }
45412 
45413  ~HideKeyboardEvent();
45414 
45417  Event * Clone() const
45418  {
45419  HideKeyboardEvent * new_event = new HideKeyboardEvent(*this);
45420  return new_event;
45421  }
45422 
45423 };
45424 
45426 class HPS_API ModifierKeys
45427 {
45428 public:
45430  ModifierKeys() : modifiers(_key_none) {}
45431 
45435  bool Equals(ModifierKeys const & in_that) const
45436  {
45437  return modifiers == in_that.modifiers;
45438  }
45439 
45443  bool operator== (ModifierKeys const & in_that) const
45444  {
45445  return Equals(in_that);
45446  }
45447 
45451  bool operator!= (ModifierKeys const & in_that) const
45452  {
45453  return !Equals(in_that);
45454  }
45455 
45458  bool None() const { return modifiers == _key_none; }
45459 
45462  bool Shift() const { return (modifiers & _key_shift) != 0; }
45463 
45466  bool Control() const { return (modifiers & _key_control) != 0; }
45467 
45470  bool Alt() const { return (modifiers & _key_alt) != 0; }
45471 
45474  bool Meta() const { return (modifiers & _key_meta) != 0; }
45475 
45478  bool CapsLock() const {return (modifiers & _key_caps_lock) != 0; }
45479 
45482  bool NumLock() const {return (modifiers & _key_num_lock) != 0; }
45483 
45486  bool ScrollLock() const {return (modifiers & _key_scroll_lock) != 0; }
45487 
45490  bool RightShift() const {return (modifiers & _key_right_shift) != 0; }
45491 
45494  bool LeftShift() const {return (modifiers & _key_left_shift) != 0; }
45495 
45498  bool RightControl() const {return (modifiers & _key_right_control) != 0; }
45499 
45502  bool LeftControl() const {return (modifiers & _key_left_control) != 0; }
45503 
45506  bool RightAlt() const {return (modifiers & _key_right_alt) != 0; }
45507 
45510  bool LeftAlt() const {return (modifiers & _key_left_alt) != 0; }
45511 
45514  bool RightMeta() const {return (modifiers & _key_right_meta) != 0; }
45515 
45518  bool LeftMeta() const {return (modifiers & _key_left_meta) != 0; }
45519 
45523  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
45524 
45528  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
45529 
45530 
45533  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
45534 
45537  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
45538 
45541  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
45542 
45545  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
45546 
45549  void CapsLock(bool in_state) { if (in_state) modifiers |= _key_caps_lock; else modifiers &= ~(_key_caps_lock); }
45550 
45553  void NumLock(bool in_state) { if (in_state) modifiers |= _key_num_lock; else modifiers &= ~(_key_num_lock); }
45554 
45557  void ScrollLock(bool in_state) { if (in_state) modifiers |= _key_scroll_lock; else modifiers &= ~(_key_scroll_lock); }
45558 
45561  void RightShift(bool in_state) { if (in_state) modifiers |= _key_right_shift; else modifiers &= ~(_key_right_shift); }
45562 
45565  void LeftShift(bool in_state) { if (in_state) modifiers |= _key_left_shift; else modifiers &= ~(_key_left_shift); }
45566 
45569  void RightControl(bool in_state) { if (in_state) modifiers |= _key_right_control; else modifiers &= ~(_key_right_control); }
45570 
45573  void LeftControl(bool in_state) { if (in_state) modifiers |= _key_left_control; else modifiers &= ~(_key_left_control); }
45574 
45577  void RightAlt(bool in_state) { if (in_state) modifiers |= _key_right_alt; else modifiers &= ~(_key_right_alt); }
45578 
45581  void LeftAlt(bool in_state) { if (in_state) modifiers |= _key_left_alt; else modifiers &= ~(_key_left_alt); }
45582 
45585  void RightMeta(bool in_state) { if (in_state) modifiers |= _key_right_meta; else modifiers &= ~(_key_right_meta); }
45586 
45589  void LeftMeta(bool in_state) { if (in_state) modifiers |= _key_left_meta; else modifiers &= ~(_key_left_meta); }
45590 
45594  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
45595  {
45596  ModifierKeys ret;
45597  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
45598  return ret;
45599  }
45600 
45604  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
45605  {
45606  ModifierKeys ret;
45607  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
45608  return ret;
45609  }
45610 
45614  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
45615 
45619  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
45620 
45621 
45625  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
45626 
45630  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
45631 
45635  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
45636 
45640  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
45641 
45644  static ModifierKeys KeyCapsLock() { ModifierKeys ret; ret.CapsLock(true); return ret; }
45645 
45648  static ModifierKeys KeyNumLock() { ModifierKeys ret; ret.NumLock(true); return ret; }
45649 
45652  static ModifierKeys KeyScrollLock() { ModifierKeys ret; ret.ScrollLock(true); return ret; }
45653 
45656  static ModifierKeys KeyRightShift() { ModifierKeys ret; ret.RightShift(true); return ret; }
45657 
45660  static ModifierKeys KeyLeftShift() { ModifierKeys ret; ret.LeftShift(true); return ret; }
45661 
45664  static ModifierKeys KeyRightControl() { ModifierKeys ret; ret.RightControl(true); return ret; }
45665 
45668  static ModifierKeys KeyLeftControl() { ModifierKeys ret; ret.LeftControl(true); return ret; }
45669 
45672  static ModifierKeys KeyRightAlt() { ModifierKeys ret; ret.RightAlt(true); return ret; }
45673 
45676  static ModifierKeys KeyLeftAlt() { ModifierKeys ret; ret.LeftAlt(true); return ret; }
45677 
45680  static ModifierKeys KeyRightMeta() { ModifierKeys ret; ret.RightMeta(true); return ret; }
45681 
45684  static ModifierKeys KeyLeftMeta() { ModifierKeys ret; ret.LeftMeta(true); return ret; }
45685 
45686 protected:
45687 
45691  {
45692  _key_none = 0x0000,
45693  _key_caps_lock = 0x0001,
45694  _key_num_lock = 0x0002,
45695  _key_scroll_lock = 0x0004,
45696  _key_right_shift = 0x0008,
45697  _key_left_shift = 0x0010,
45698  _key_right_control = 0x0020,
45699  _key_left_control = 0x0040,
45700  _key_right_alt = 0x0080,
45701  _key_left_alt = 0x0100,
45702  _key_right_meta = 0x0200,
45703  _key_left_meta = 0x0400,
45704  _key_shift = _key_left_shift | _key_right_shift,
45705  _key_control = _key_left_control | _key_right_control,
45706  _key_alt = _key_left_alt | _key_right_alt,
45707  _key_meta = _key_left_meta | _key_right_meta,
45708  };
45709 
45710  int modifiers;
45711 };
45712 
45713 
45716 class HPS_API InputEvent : public Event
45717 {
45718 public:
45719 
45721  InputEvent() : Event() { channel = GetClassID(); }
45722 
45725  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
45726 
45727  ~InputEvent();
45728 
45731  Event * Clone() const
45732  {
45733  InputEvent * new_event = new InputEvent(*this);
45734  return new_event;
45735  }
45736 
45740  virtual bool Equals(InputEvent const & in_that) const
45741  {
45742  return ModifierKeyState == in_that.ModifierKeyState;
45743  }
45744 
45748  virtual bool operator== (InputEvent const & in_that) const
45749  {
45750  return Equals(in_that);
45751  }
45752 
45756  virtual bool operator!= (InputEvent const & in_that) const
45757  {
45758  return !Equals(in_that);
45759  }
45760 
45764  {
45765  return ModifierKeyState;
45766  }
45767 
45769 };
45770 
45772 class HPS_API TouchEvent : public InputEvent
45773 {
45774 public:
45777  enum class Action : uint32_t
45778  {
45779  TouchDown,
45780  TouchUp,
45781  Move,
45782  };
45783 
45785  TouchEvent() : InputEvent() { channel = GetClassID(); }
45786 
45791  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
45792  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
45793 
45799  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
45800  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
45801 
45808  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
45809  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
45810 
45811 
45814  TouchEvent(Event const & in_event) : InputEvent()
45815  {
45816  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
45817  {
45818  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
45819  channel = GetClassID();
45820  CurrentAction = event->CurrentAction;
45821  Touches = event->Touches;
45822  ModifierKeyState = event->ModifierKeyState;
45823  }
45824  else
45825  throw HPS::InvalidSpecificationException("Invalid Event type to cast from.");
45826  }
45827 
45828  ~TouchEvent();
45829 
45830 
45833  Event * Clone() const
45834  {
45835  TouchEvent * new_event = new TouchEvent(*this);
45836  return new_event;
45837  }
45838 
45842  virtual bool Equals(TouchEvent const & in_that) const
45843  {
45844  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
45845  }
45846 
45850  virtual bool operator== (TouchEvent const & in_that) const
45851  {
45852  return Equals(in_that);
45853  }
45854 
45858  virtual bool operator!= (TouchEvent const & in_that) const
45859  {
45860  return !Equals(in_that);
45861  }
45862 
45866  virtual bool Drop(Event const * in_that_event) const
45867  {
45868  HPS::TouchEvent const * that_touch_event = static_cast<HPS::TouchEvent const *>(in_that_event);
45869 
45870  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
45871  && Touches.size() == that_touch_event->Touches.size() )
45872  {
45873  TouchArray these_touches = Touches;
45874  TouchArray those_touches = that_touch_event->Touches;
45875 
45876  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
45877  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
45878 
45879  for (size_t i = 0 ; i < these_touches.size() ; i++)
45880  {
45881  if (these_touches[i].ID != those_touches[i].ID)
45882  return false;
45883  }
45884  return true;
45885  }
45886 
45887  return false;
45888  }
45889 
45891  HPS::TouchArray Touches;
45892 
45893 private:
45899  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
45900  {
45901  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
45902  }
45903 };
45904 
45905 
45907 class HPS_API MouseButtons
45908 {
45909 public:
45911  MouseButtons() : buttons(_button_none) {}
45912 
45916  bool Equals(MouseButtons const & in_that) const
45917  {
45918  return buttons == in_that.buttons;
45919  }
45920 
45924  bool operator== (MouseButtons const & in_that) const
45925  {
45926  return Equals(in_that);
45927  }
45928 
45932  bool operator!= (MouseButtons const & in_that) const
45933  {
45934  return !Equals(in_that);
45935  }
45936 
45939  bool None() const { return buttons == _button_none; }
45940 
45943  bool Left() const { return (buttons & _button_left) != 0; }
45944 
45947  bool Right() const { return (buttons & _button_right) != 0; }
45948 
45951  bool Middle() const { return (buttons & _button_middle) != 0; }
45952 
45955  bool X1() const { return (buttons & _button_x1) != 0; }
45956 
45959  bool X2() const { return (buttons & _button_x2) != 0; }
45960 
45961 
45965  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
45966 
45970  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
45971 
45974  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
45975 
45978  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
45979 
45982  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
45983 
45986  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
45987 
45990  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
45991 
45995  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
45996  {
45997  MouseButtons ret;
45998  ret.buttons = buttons | in_buttons_to_merge.buttons;
45999  return ret;
46000  }
46001 
46005  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
46006  {
46007  MouseButtons ret;
46008  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
46009  return ret;
46010  }
46011 
46015  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
46016 
46020  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
46021 
46022 
46025  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
46026 
46029  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
46030 
46033  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
46034 
46037  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
46038 
46041  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
46042 
46043 protected:
46044 
46047  enum Buttons
46048  {
46049  _button_none = 0x0000,
46050  _button_left = 0x0001,
46051  _button_right = 0x0002,
46052  _button_middle = 0x0004,
46053  _button_x1 = 0x0008,
46054  _button_x2 = 0x0010
46055  };
46056 
46057  int buttons;
46058 };
46059 
46061 class HPS_API MouseEvent : public InputEvent
46062 {
46063 public:
46064 
46067  enum class Action : uint32_t
46068  {
46069  ButtonUp,
46070  ButtonDown,
46071  Move,
46072  Scroll,
46073  Enter,
46074  Leave
46075  };
46076 
46078  MouseEvent() : InputEvent() { channel = GetClassID(); }
46079 
46086  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
46087  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
46088 
46096  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)
46097  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
46098 
46101  MouseEvent(Event const & in_event) : InputEvent()
46102  {
46103  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
46104  {
46105  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
46106  channel = GetClassID();
46107  CurrentAction = event->CurrentAction;
46108  Location = event->Location;
46109  CurrentButton = event->CurrentButton;
46110  WheelDelta = event->WheelDelta;
46111  ClickCount = event->ClickCount;
46112  }
46113  else
46114  {
46115  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
46116  }
46117  }
46118 
46119  ~MouseEvent();
46120 
46123  Event * Clone() const
46124  {
46125  MouseEvent * new_event = new MouseEvent(*this);
46126  return new_event;
46127  }
46128 
46132  virtual bool Equals(MouseEvent const & in_that) const
46133  {
46134  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
46135  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
46136  && Location == in_that.Location && ClickCount == in_that.ClickCount;
46137  }
46138 
46142  virtual bool operator== (MouseEvent const & in_that) const
46143  {
46144  return Equals(in_that);
46145  }
46146 
46150  virtual bool operator!= (MouseEvent const & in_that) const
46151  {
46152  return !Equals(in_that);
46153  }
46154 
46158  virtual bool Drop(Event const * in_that_event) const
46159  {
46160  HPS::MouseEvent const * that_mouse_event = static_cast<HPS::MouseEvent const *>(in_that_event);
46161 
46162  if (CurrentAction == that_mouse_event->CurrentAction &&
46163  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
46164  CurrentButton == that_mouse_event->CurrentButton)
46165  return true;
46166 
46167  return false;
46168  }
46169 
46170  virtual intptr_t Freshen() const {
46171 
46172  if (CurrentAction == Action::Move)
46173  return GetClassID();
46174 
46175  return 0;
46176  }
46177 
46181  float WheelDelta;
46182  size_t ClickCount;
46183 };
46184 
46185 
46187 class HPS_API KeyboardEvent : public InputEvent
46188 {
46189 public:
46192  enum class Action : uint32_t
46193  {
46194  None,
46195  KeyDown,
46196  KeyUp
46197  };
46198 
46200  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
46201 
46206  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
46207 
46213  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
46214  : InputEvent(in_modifiers), CurrentAction(in_action)
46215  {
46216  channel = GetClassID();
46217  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
46218  }
46219 
46224  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
46225  : InputEvent(in_modifiers), CurrentAction(in_action)
46226  {
46227  channel = GetClassID();
46228  KeyboardCodes = in_keyboardcodes;
46229  }
46230 
46233  KeyboardEvent(Event const & in_event) : InputEvent()
46234  {
46235  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
46236  {
46237  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
46238  channel = GetClassID();
46239  KeyboardCodes = event->KeyboardCodes;
46240  CurrentAction = event->CurrentAction;
46241  }
46242  else
46243  {
46244  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
46245  }
46246  }
46247 
46248  ~KeyboardEvent();
46249 
46252  Event * Clone() const
46253  {
46254  KeyboardEvent * new_event = new KeyboardEvent(*this);
46255  return new_event;
46256  }
46257 
46261  virtual bool Equals(KeyboardEvent const & in_that) const
46262  {
46263  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
46264  }
46265 
46269  virtual bool operator== (KeyboardEvent const & in_that) const
46270  {
46271  return Equals(in_that);
46272  }
46273 
46277  virtual bool operator!= (KeyboardEvent const & in_that) const
46278  {
46279  return !Equals(in_that);
46280  }
46281 
46285  void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
46286  {
46287  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
46288  }
46289 
46292  void SetKeyboardCodes(HPS::KeyboardCodeArray const & in_keyboardcodes)
46293  {
46294  KeyboardCodes = in_keyboardcodes;
46295  }
46296 
46297  HPS::KeyboardCodeArray KeyboardCodes;
46299 };
46300 
46301 
46303 class HPS_API MouseState : public Object
46304 {
46305 public:
46307  MouseState();
46308 
46311  MouseState(MouseState const & in_that);
46312 
46316  MouseState(MouseState && in_that);
46317 
46321  MouseState & operator=(MouseState && in_that);
46322 
46323  ~MouseState();
46324 
46325  HPS::Type ObjectType() const {return HPS::Type::MouseState;};
46326 
46329  void Assign(MouseState const & in_that);
46330 
46334  MouseState & operator=(MouseState const & in_that);
46335 
46339  bool Equals(MouseState const & in_that) const;
46340 
46344  bool operator== (MouseState const & in_that) const;
46345 
46349  bool operator!= (MouseState const & in_that) const;
46350 
46355  bool HasAll(MouseButtons in_mouse_trigger, ModifierKeys in_modifier_trigger) const;
46356 
46363  void Set(KeyArray const & in_path, MouseEvent const & in_event, WindowPoint const & in_point, MouseButtons in_buttons = MouseButtons(), ModifierKeys in_modifiers = ModifierKeys());
46364 
46367  HPS::MouseEvent GetActiveEvent() const;
46368 
46372  HPS::WindowKey GetEventSource() const;
46373 
46377  HPS::KeyArray GetEventPath() const;
46378 
46381  MouseButtons GetButtons() const;
46382 
46385  WindowPoint GetLocation() const;
46386 
46389  ModifierKeys GetModifierKeys() const;
46390 
46393  void SetActiveEvent(MouseEvent const & in_event);
46394 
46397  void SetEventPath(KeyArray const & in_path);
46398 
46401  void SetButtons(MouseButtons in_buttons);
46402 
46405  void SetLocation(WindowPoint const & in_point);
46406 
46409  void SetModifierKeys(ModifierKeys in_modifiers);
46410 };
46411 
46412 
46413 
46415 class HPS_API TouchState : public Object
46416 {
46417 public:
46419  TouchState();
46420 
46423  TouchState(TouchState const & in_that);
46424 
46428  TouchState(TouchState && in_that);
46429 
46433  TouchState & operator=(TouchState && in_that);
46434 
46435  ~TouchState();
46436 
46437  HPS::Type ObjectType() const {return HPS::Type::TouchState;};
46438 
46441  void Assign(TouchState const & in_that);
46442 
46446  TouchState & operator=(TouchState const & in_that);
46447 
46451  bool Equals(TouchState const & in_that) const;
46452 
46456  bool operator== (TouchState const & in_that) const;
46457 
46461  bool operator!= (TouchState const & in_that) const;
46462 
46468  void Set(KeyArray const & in_path, TouchEvent const & in_event, TouchArray const & in_touches, ModifierKeys in_modifiers = ModifierKeys());
46469 
46472  HPS::TouchEvent GetActiveEvent() const;
46473 
46477  HPS::WindowKey GetEventSource() const;
46478 
46482  HPS::KeyArray GetEventPath() const;
46483 
46486  size_t GetTouchCount() const;
46487 
46490  HPS::TouchArray GetTouches() const;
46491 
46494  ModifierKeys GetModifierKeys() const;
46495 
46498  void SetActiveEvent(TouchEvent const & in_event);
46499 
46502  void SetEventPath(KeyArray const & in_path);
46503 
46506  void SetTouches(TouchArray const & in_touches);
46507 
46510  void SetModifierKeys(ModifierKeys in_modifiers);
46511 };
46512 
46513 
46514 
46516 class HPS_API KeyboardState : public Object
46517 {
46518 public:
46520  KeyboardState();
46521 
46524  KeyboardState(KeyboardState const & in_that);
46525 
46529  KeyboardState(KeyboardState && in_that);
46530 
46534  KeyboardState & operator=(KeyboardState && in_that);
46535 
46536  ~KeyboardState();
46537 
46538  HPS::Type ObjectType() const {return HPS::Type::KeyboardState;};
46539 
46542  void Assign(KeyboardState const & in_that);
46543 
46547  KeyboardState & operator=(KeyboardState const & in_that);
46548 
46552  bool Equals(KeyboardState const & in_that) const;
46553 
46557  bool operator== (KeyboardState const & in_that) const;
46558 
46562  bool operator!= (KeyboardState const & in_that) const;
46563 
46569  void Set(KeyArray const & in_path, KeyboardEvent const & in_event, KeyboardCodeArray const & in_keyboard_codes, ModifierKeys in_modifiers = ModifierKeys());
46570 
46573  HPS::KeyboardEvent GetActiveEvent() const;
46574 
46578  HPS::WindowKey GetEventSource() const;
46579 
46583  HPS::KeyArray GetEventPath() const;
46584 
46587  size_t GetKeyboardCodeCount() const;
46588 
46591  HPS::KeyboardCodeArray GetKeyboardCodes() const;
46592 
46596  bool GetKeyState(HPS::KeyboardCode in_key_code) const;
46597 
46600  ModifierKeys GetModifierKeys() const;
46601 
46604  void SetActiveEvent(KeyboardEvent const & in_event);
46605 
46608  void SetEventPath(KeyArray const & in_path);
46609 
46612  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboard_codes);
46613 
46616  void SetModifierKeys(ModifierKeys in_modifiers);
46617 };
46618 
46619 
46622 class HPS_API IONotifier : public Object
46623 {
46624 public:
46626  IONotifier();
46627 
46630  IONotifier(IONotifier const & in_that);
46631 
46635  IONotifier(IONotifier && in_that);
46636 
46640  IONotifier & operator=(IONotifier && in_that);
46641 
46642  virtual ~IONotifier();
46643 
46644  HPS::Type ObjectType() const {return HPS::Type::IONotifier;};
46645 
46649  IONotifier & operator=(IONotifier const & in_that);
46650 
46653  void Assign(IONotifier const & in_that);
46654 
46656  void Wait();
46657 
46660  IOResult Status() const;
46661 
46665  IOResult Status(float & out_percent_complete) const;
46666 
46670  void Cancel();
46671 };
46672 
46676 
46678 class HPS_API PointCloud
46679 {
46680 public:
46682 class HPS_API ImportResultsKit : public Kit
46683  {
46684  public:
46686  ImportResultsKit();
46687 
46690  ImportResultsKit(ImportResultsKit const & in_kit);
46691 
46695  ImportResultsKit(ImportResultsKit && in_that);
46696 
46700  ImportResultsKit & operator=(ImportResultsKit && in_that);
46701 
46702  virtual ~ImportResultsKit();
46703 
46704  HPS::Type ObjectType() const { return HPS::Type::PointCloudImportResultsKit; };
46705 
46708  void Set(ImportResultsKit const & in_kit);
46709 
46712  void Show(ImportResultsKit & out_kit) const;
46713 
46717  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
46718 
46721  bool Empty() const;
46722 
46726  bool Equals(ImportResultsKit const & in_kit) const;
46727 
46731  bool operator==(ImportResultsKit const & in_kit) const;
46732 
46736  bool operator!=(ImportResultsKit const & in_kit) const;
46737 
46742  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
46743 
46747  ImportResultsKit & UnsetSegment();
46748 
46753  bool ShowSegment(SegmentKey & out_segment) const;
46754 
46757  ImportResultsKit & UnsetEverything();
46758  };
46759 
46761  class HPS_API ImportOptionsKit : public Kit
46762  {
46763  public:
46765  ImportOptionsKit();
46766 
46769  ImportOptionsKit(ImportOptionsKit const & in_kit);
46770 
46774  ImportOptionsKit(ImportOptionsKit && in_that);
46775 
46779  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
46780 
46781  virtual ~ImportOptionsKit();
46782 
46783  HPS::Type ObjectType() const { return HPS::Type::PointCloudImportOptionsKit; };
46784 
46787  void Set(ImportOptionsKit const & in_kit);
46788 
46791  void Show(ImportOptionsKit & out_kit) const;
46792 
46796  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
46797 
46800  bool Empty() const;
46801 
46805  bool Equals(ImportOptionsKit const & in_kit) const;
46806 
46810  bool operator==(ImportOptionsKit const & in_kit) const;
46811 
46815  bool operator!=(ImportOptionsKit const & in_kit) const;
46816 
46821  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
46822 
46825  ImportOptionsKit & UnsetSegment();
46826 
46830  bool ShowSegment(SegmentKey & out_segment) const;
46831 
46837  ImportOptionsKit & SetPointColor(RGBColor const & in_color);
46838 
46841  ImportOptionsKit & UnsetPointColor();
46842 
46846  bool ShowPointColor(RGBColor & out_color) const;
46847 
46850  ImportOptionsKit & UnsetEverything();
46851  };
46852 
46853 
46856  class HPS_API ImportNotifier : public IONotifier
46857  {
46858  public:
46860  ImportNotifier();
46861 
46864  ImportNotifier(ImportNotifier const & in_that);
46865 
46870  ImportNotifier(IONotifier const & in_that);
46871 
46875  ImportNotifier(ImportNotifier && in_that);
46876 
46880  ImportNotifier & operator=(ImportNotifier && in_that);
46881 
46882  virtual ~ImportNotifier();
46883 
46884  HPS::Type ObjectType() const {return HPS::Type::PointCloudImportNotifier;};
46885 
46889  ImportNotifier & operator=(ImportNotifier const & in_that);
46890 
46893  void Assign(ImportNotifier const & in_that);
46894 
46898  ImportResultsKit GetResults() const;
46899  };
46900 
46901 
46903  class HPS_API File
46904  {
46905  public:
46911  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
46912 
46913  private:
46915  File();
46916  };
46917 private:
46919  PointCloud();
46920 };
46921 
46925 
46927 class HPS_API Stream
46928 {
46929 public:
46930  class ImportNotifier;
46931  class ImportOptionsKit;
46932 
46934  class HPS_API Toolkit : public Object
46935  {
46936  public:
46938  Toolkit();
46939 
46942  Toolkit(Toolkit const & in_toolkit);
46943 
46947  Toolkit(Toolkit && in_toolkit);
46948 
46952  Toolkit & operator=(Toolkit const & in_toolkit);
46953 
46957  Toolkit & operator=(Toolkit && in_toolkit);
46958 
46959  HPS::Type ObjectType() const { return HPS::Type::StreamToolkit; }
46960 
46962  virtual void Restart();
46963 
46964  ImportNotifier ParseBuffers(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
46965  };
46966 
46969  static Toolkit CreateToolkit();
46970 
46971 
46972 
46974 
46976  class HPS_API ExportEvent
46977  {
46978  protected:
46979  ExportEvent() {}
46980  public:
46981  virtual ~ExportEvent();
46983  intptr_t GetClassID() const;
46986  HPS::ByteArray non_db_user_data;
46987  };
46988 
46990  class HPS_API ExportEventHandler
46991  {
46992  public:
46993  ExportEventHandler() {}
46994  virtual ~ExportEventHandler();
46998  virtual void Handle(ExportEvent * in_event);
46999  };
47000 
47002 
47004  class HPS_API GeometryExportEvent : public ExportEvent
47005  {
47007  GeometryExportEvent & operator=(GeometryExportEvent const &);
47008  public:
47009  GeometryExportEvent();
47010  virtual ~GeometryExportEvent();
47011  GeometryExportEvent(HPS::Key & in_key);
47012 
47015  };
47016 
47018  class HPS_API SegmentExportEvent : public ExportEvent
47019  {
47021  SegmentExportEvent & operator=(SegmentExportEvent const &);
47022  public:
47023  SegmentExportEvent();
47024  virtual ~SegmentExportEvent();
47025  SegmentExportEvent(HPS::SegmentKey & in_segment_key);
47026 
47029  };
47030 
47032 
47034  class HPS_API ImportEvent
47035  {
47036  protected:
47037  ImportEvent() {}
47038  public:
47039  virtual ~ImportEvent();
47041  intptr_t GetClassID() const;
47042  };
47043 
47048  class HPS_API ImportEventHandler
47049  {
47050  public:
47051  ImportEventHandler() {}
47052  virtual ~ImportEventHandler();
47053 
47059  virtual bool Handle(ImportEvent * in_event);
47060  };
47061 
47063 
47064  class HPS_API AttributeLockImportEvent : public ImportEvent
47065  {
47067  AttributeLockImportEvent & operator=(AttributeLockImportEvent const &);
47068  public:
47069  AttributeLockImportEvent();
47070  virtual ~AttributeLockImportEvent();
47071  AttributeLockImportEvent(HPS::SegmentKey & in_segment_key, HPS::AttributeLockKit & in_attribute_lock_kit);
47072 
47073  HPS::SegmentKey & segment_key;
47074  HPS::AttributeLockKit & attribute_lock_kit;
47075  };
47076 
47077  class HPS_API BoundingImportEvent : public ImportEvent
47078  {
47080  BoundingImportEvent & operator=(BoundingImportEvent const &);
47081  public:
47082  BoundingImportEvent();
47083  virtual ~BoundingImportEvent();
47084  BoundingImportEvent(HPS::SegmentKey & in_segment_key, HPS::BoundingKit & in_bounding_kit);
47085 
47086  HPS::SegmentKey & segment_key;
47087  HPS::BoundingKit & bounding_kit;
47088  };
47089 
47090  class HPS_API CameraImportEvent : public ImportEvent
47091  {
47093  CameraImportEvent & operator=(CameraImportEvent const &);
47094  public:
47095  CameraImportEvent();
47096  virtual ~CameraImportEvent();
47097  CameraImportEvent(HPS::SegmentKey & in_segment_key, HPS::CameraKit & in_camera_kit);
47098 
47099  HPS::SegmentKey & segment_key;
47100  HPS::CameraKit & camera_kit;
47101  };
47102 
47103  class HPS_API CircleImportEvent : public ImportEvent
47104  {
47106  CircleImportEvent & operator=(CircleImportEvent const &);
47107  public:
47108  CircleImportEvent();
47109  virtual ~CircleImportEvent();
47110  CircleImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircleKit & in_circle_kit);
47111 
47112  HPS::SegmentKey & segment_key;
47113  HPS::CircleKit & circle_kit;
47114  };
47115 
47116  class HPS_API CircularArcImportEvent : public ImportEvent
47117  {
47119  CircularArcImportEvent & operator=(CircularArcImportEvent const &);
47120  public:
47121  CircularArcImportEvent();
47122  virtual ~CircularArcImportEvent();
47123  CircularArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularArcKit & in_circular_arc_kit);
47124 
47125  HPS::SegmentKey & segment_key;
47126  HPS::CircularArcKit & circular_arc_kit;
47127  };
47128 
47129  class HPS_API CircularWedgeImportEvent : public ImportEvent
47130  {
47132  CircularWedgeImportEvent & operator=(CircularWedgeImportEvent const &);
47133  public:
47134  CircularWedgeImportEvent();
47135  virtual ~CircularWedgeImportEvent();
47136  CircularWedgeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CircularWedgeKit & in_circular_wedge_kit);
47137 
47138  HPS::SegmentKey & segment_key;
47139  HPS::CircularWedgeKit & circular_wedge_kit;
47140  };
47141 
47143  {
47145  ColorInterpolationImportEvent & operator=(ColorInterpolationImportEvent const &);
47146  public:
47147  ColorInterpolationImportEvent();
47148  virtual ~ColorInterpolationImportEvent();
47149  ColorInterpolationImportEvent(HPS::SegmentKey & in_segment_key, HPS::ColorInterpolationKit & in_color_interpolation_kit);
47150 
47151  HPS::SegmentKey & segment_key;
47152  HPS::ColorInterpolationKit & color_interpolation_kit;
47153  };
47154 
47155  class HPS_API CommentImportEvent : public ImportEvent
47156  {
47158  CommentImportEvent & operator=(CommentImportEvent const &);
47159  public:
47160  CommentImportEvent();
47161  virtual ~CommentImportEvent();
47162  CommentImportEvent(HPS::SegmentKey & in_segment_key, const char* in_comment);
47163 
47164  HPS::SegmentKey & segment_key;
47165  HPS::UTF8 const comment;
47166  };
47167 
47168  class HPS_API ConditionImportEvent : public ImportEvent
47169  {
47171  ConditionImportEvent & operator=(ConditionImportEvent const &);
47172  public:
47173  ConditionImportEvent();
47174  virtual ~ConditionImportEvent();
47175  ConditionImportEvent(HPS::SegmentKey & in_segment_key);
47176 
47177  HPS::SegmentKey & segment_key;
47178  HPS::UTF8Array conditions;
47179  };
47180 
47181  class HPS_API ContourLineImportEvent : public ImportEvent
47182  {
47184  ContourLineImportEvent & operator=(ContourLineImportEvent const &);
47185  public:
47186  ContourLineImportEvent();
47187  virtual ~ContourLineImportEvent();
47188  ContourLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::ContourLineKit & in_contour_line_kit);
47189 
47190  HPS::SegmentKey & segment_key;
47191  HPS::ContourLineKit & contour_line_kit;
47192  };
47193 
47195  {
47197  CuttingSectionImportEvent & operator=(CuttingSectionImportEvent const &);
47198  public:
47199  CuttingSectionImportEvent();
47200  virtual ~CuttingSectionImportEvent();
47201  CuttingSectionImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionKit & in_cutting_section_kit);
47202 
47203  HPS::SegmentKey & segment_key;
47204  HPS::CuttingSectionKit & cutting_section_kit;
47205  };
47206 
47208  {
47210  CuttingSectionAttributeImportEvent & operator=(CuttingSectionAttributeImportEvent const &);
47211  public:
47212  CuttingSectionAttributeImportEvent();
47213  virtual ~CuttingSectionAttributeImportEvent();
47214  CuttingSectionAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CuttingSectionAttributeKit & in_cutting_section_attribute_kit);
47215 
47216  HPS::SegmentKey & segment_key;
47217  HPS::CuttingSectionAttributeKit & cutting_section_attribute_kit;
47218  };
47219 
47221  {
47223  CubeMapDefinitionImportEvent & operator=(CubeMapDefinitionImportEvent const &);
47224  public:
47225  CubeMapDefinitionImportEvent();
47226  virtual ~CubeMapDefinitionImportEvent();
47227  CubeMapDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name,
47228  HPS::ImageDefinition & in_negative_z, HPS::ImageDefinition & in_positive_z,
47229  HPS::ImageDefinition & in_negative_x, HPS::ImageDefinition & in_positive_x,
47230  HPS::ImageDefinition & in_negative_y, HPS::ImageDefinition & in_positive_y,
47231  HPS::TextureOptionsKit & in_texture_kit);
47232 
47233  HPS::PortfolioKey & portfolio_key;
47234  UTF8 name;
47235  HPS::ImageDefinition & negative_z;
47236  HPS::ImageDefinition & positive_z;
47237  HPS::ImageDefinition & negative_x;
47238  HPS::ImageDefinition & positive_x;
47239  HPS::ImageDefinition & negative_y;
47240  HPS::ImageDefinition & positive_y;
47241  HPS::TextureOptionsKit & texture_kit;
47242  };
47243 
47244  class HPS_API CullingImportEvent : public ImportEvent
47245  {
47247  CullingImportEvent & operator=(CullingImportEvent const &);
47248  public:
47249  CullingImportEvent();
47250  virtual ~CullingImportEvent();
47251  CullingImportEvent(HPS::SegmentKey & in_segment_key, HPS::CullingKit & in_culling_kit);
47252 
47253  HPS::SegmentKey & segment_key;
47254  HPS::CullingKit & culling_kit;
47255  };
47256 
47258  {
47260  CurveAttributeImportEvent & operator=(CurveAttributeImportEvent const &);
47261  public:
47262  CurveAttributeImportEvent();
47263  virtual ~CurveAttributeImportEvent();
47264  CurveAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CurveAttributeKit & in_curve_attribute_kit);
47265 
47266  HPS::SegmentKey & segment_key;
47267  HPS::CurveAttributeKit & curve_attribute_kit;
47268  };
47269 
47271  {
47273  CylinderAttributeImportEvent & operator=(CylinderAttributeImportEvent const &);
47274  public:
47275  CylinderAttributeImportEvent();
47276  virtual ~CylinderAttributeImportEvent();
47277  CylinderAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderAttributeKit & in_cylinder_attribute_kit);
47278 
47279  HPS::SegmentKey & segment_key;
47280  HPS::CylinderAttributeKit & cylinder_attribute_kit;
47281  };
47282 
47283  class HPS_API CylinderImportEvent : public ImportEvent
47284  {
47286  CylinderImportEvent & operator=(CylinderImportEvent const &);
47287  public:
47288  CylinderImportEvent();
47289  virtual ~CylinderImportEvent();
47290  CylinderImportEvent(HPS::SegmentKey & in_segment_key, HPS::CylinderKit & in_cylinder_kit);
47291 
47292  HPS::SegmentKey & segment_key;
47293  HPS::CylinderKit & cylinder_kit;
47294  };
47295 
47297  {
47299  DistantLightPropertyImportEvent & operator=(DistantLightPropertyImportEvent const &);
47300  public:
47301  DistantLightPropertyImportEvent();
47302  virtual ~DistantLightPropertyImportEvent();
47303  DistantLightPropertyImportEvent(HPS::DistantLightKey & in_distant_light_key, HPS::DistantLightKit & in_distant_light_kit);
47304 
47305  HPS::DistantLightKey & distant_light_key;
47306  HPS::DistantLightKit & distant_light_kit;
47307  };
47308 
47309  class HPS_API DistantLightImportEvent : public ImportEvent
47310  {
47312  DistantLightImportEvent & operator=(DistantLightImportEvent const &);
47313  public:
47314  DistantLightImportEvent();
47315  virtual ~DistantLightImportEvent();
47316  DistantLightImportEvent(HPS::SegmentKey & in_segment_key, HPS::DistantLightKit & in_distantlight_kit);
47317 
47318  HPS::SegmentKey & segment_key;
47319  HPS::DistantLightKit & distant_light_kit;
47320  };
47321 
47323  {
47325  DrawingAttributeImportEvent & operator=(DrawingAttributeImportEvent const &);
47326  public:
47327  DrawingAttributeImportEvent();
47328  virtual ~DrawingAttributeImportEvent();
47329  DrawingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::DrawingAttributeKit & in_drawing_attribute_kit);
47330 
47331  HPS::SegmentKey & segment_key;
47332  HPS::DrawingAttributeKit & drawing_attribute_kit;
47333  };
47334 
47335  class HPS_API EdgeAttributeImportEvent : public ImportEvent
47336  {
47338  EdgeAttributeImportEvent & operator=(EdgeAttributeImportEvent const &);
47339  public:
47340  EdgeAttributeImportEvent();
47341  virtual ~EdgeAttributeImportEvent();
47342  EdgeAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::EdgeAttributeKit & in_edge_attribute_kit);
47343 
47344  HPS::SegmentKey & segment_key;
47345  HPS::EdgeAttributeKit & edge_attribute_kit;
47346  };
47347 
47348  class HPS_API EllipseImportEvent : public ImportEvent
47349  {
47351  EllipseImportEvent & operator=(EllipseImportEvent const &);
47352  public:
47353  EllipseImportEvent();
47354  virtual ~EllipseImportEvent();
47355  EllipseImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipseKit & in_ellipse_kit);
47356 
47357  HPS::SegmentKey & segment_key;
47358  HPS::EllipseKit & ellipse_kit;
47359  };
47360 
47361  class HPS_API EllipticalArcImportEvent : public ImportEvent
47362  {
47364  EllipticalArcImportEvent & operator=(EllipticalArcImportEvent const &);
47365  public:
47366  EllipticalArcImportEvent();
47367  virtual ~EllipticalArcImportEvent();
47368  EllipticalArcImportEvent(HPS::SegmentKey & in_segment_key, HPS::EllipticalArcKit & in_elliptical_arc_kit);
47369 
47370  HPS::SegmentKey & segment_key;
47371  HPS::EllipticalArcKit & elliptical_arc_kit;
47372  };
47373 
47375  {
47377  GlyphDefinitionImportEvent & operator=(GlyphDefinitionImportEvent const &);
47378  public:
47379  GlyphDefinitionImportEvent();
47380  virtual ~GlyphDefinitionImportEvent();
47381  GlyphDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::GlyphKit & in_glyph_kit);
47382 
47383  HPS::PortfolioKey & portfolio_key;
47384  UTF8 name;
47385  HPS::GlyphKit & glyph_kit;
47386  };
47387 
47389  {
47391  ShapeDefinitionImportEvent & operator=(ShapeDefinitionImportEvent const &);
47392  public:
47393  ShapeDefinitionImportEvent();
47394  virtual ~ShapeDefinitionImportEvent();
47395  ShapeDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ShapeKit & in_shape_kit);
47396 
47397  HPS::PortfolioKey & portfolio_key;
47398  UTF8 name;
47399  HPS::ShapeKit & shape_kit;
47400  };
47401 
47402  class HPS_API GridImportEvent : public ImportEvent
47403  {
47405  GridImportEvent & operator=(GridImportEvent const &);
47406  public:
47407  GridImportEvent();
47408  virtual ~GridImportEvent();
47409  GridImportEvent(HPS::SegmentKey & in_segment_key, HPS::GridKit & in_grid_kit);
47410 
47411  HPS::SegmentKey & segment_key;
47412  HPS::GridKit & grid_kit;
47413  };
47414 
47416  {
47418  HiddenLineAttributeImportEvent & operator=(HiddenLineAttributeImportEvent const &);
47419  public:
47420  HiddenLineAttributeImportEvent();
47421  virtual ~HiddenLineAttributeImportEvent();
47422  HiddenLineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::HiddenLineAttributeKit & in_hidden_attribute_kit);
47423 
47424  HPS::SegmentKey & segment_key;
47425  HPS::HiddenLineAttributeKit & hidden_line_attribute_kit;
47426  };
47427 
47429  {
47431  ImageDefinitionImportEvent & operator=(ImageDefinitionImportEvent const &);
47432  public:
47433  ImageDefinitionImportEvent();
47434  virtual ~ImageDefinitionImportEvent();
47435  ImageDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ImageKit & in_image_kit);
47436 
47437  HPS::PortfolioKey & portfolio_key;
47438  UTF8 name;
47439  HPS::ImageKit & image_kit;
47440  };
47441 
47443  {
47445  IncludeSegmentImportEvent & operator=(IncludeSegmentImportEvent const &);
47446  public:
47447  IncludeSegmentImportEvent();
47448  virtual ~IncludeSegmentImportEvent();
47449  IncludeSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_reference_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
47450 
47451  HPS::SegmentKey & segment_key;
47452  HPS::SegmentKey & reference_segment_key;
47453  HPS::ConditionalExpression & condition;
47454  HPS::AttributeLockTypeArray filter_types;
47455  };
47456 
47457  class HPS_API InfiniteLineImportEvent : public ImportEvent
47458  {
47460  InfiniteLineImportEvent & operator=(InfiniteLineImportEvent const &);
47461  public:
47462  InfiniteLineImportEvent();
47463  virtual ~InfiniteLineImportEvent();
47464  InfiniteLineImportEvent(HPS::SegmentKey & in_segment_key, HPS::InfiniteLineKit & in_infinite_line_kit);
47465 
47466  HPS::SegmentKey & segment_key;
47467  HPS::InfiniteLineKit & infinite_line_kit;
47468  };
47469 
47471  {
47473  LightingAttributeImportEvent & operator=(LightingAttributeImportEvent const &);
47474  public:
47475  LightingAttributeImportEvent();
47476  virtual ~LightingAttributeImportEvent();
47477  LightingAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LightingAttributeKit & in_lighting_attribute_kit);
47478 
47479  HPS::SegmentKey & segment_key;
47480  HPS::LightingAttributeKit & lighting_attribute_kit;
47481  };
47482 
47483  class HPS_API LineAttributeImportEvent : public ImportEvent
47484  {
47486  LineAttributeImportEvent & operator=(LineAttributeImportEvent const &);
47487  public:
47488  LineAttributeImportEvent();
47489  virtual ~LineAttributeImportEvent();
47490  LineAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineAttributeKit & in_line_attribute_kit);
47491 
47492  HPS::SegmentKey & segment_key;
47493  HPS::LineAttributeKit & line_attribute_kit;
47494  };
47495 
47496  class HPS_API LineImportEvent : public ImportEvent
47497  {
47499  LineImportEvent & operator=(LineImportEvent const &);
47500  public:
47501  LineImportEvent();
47502  virtual ~LineImportEvent();
47503  LineImportEvent(HPS::SegmentKey & in_segment_key, HPS::LineKit & in_line_kit);
47504 
47505  HPS::SegmentKey & segment_key;
47506  HPS::LineKit & line_kit;
47507  };
47508 
47510  {
47512  LinePatternDefinitionImportEvent & operator=(LinePatternDefinitionImportEvent const &);
47513  public:
47514  LinePatternDefinitionImportEvent();
47515  virtual ~LinePatternDefinitionImportEvent();
47516  LinePatternDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::LinePatternKit & in_line_pattern_kit);
47517 
47518  HPS::PortfolioKey & portfolio_key;
47519  UTF8 name;
47520  HPS::LinePatternKit & line_pattern_kit;
47521  };
47522 
47523  class HPS_API MarkerImportEvent : public ImportEvent
47524  {
47526  MarkerImportEvent & operator=(MarkerImportEvent const &);
47527  public:
47528  MarkerImportEvent();
47529  virtual ~MarkerImportEvent();
47530  MarkerImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerKit & in_marker_kit);
47531 
47532  HPS::SegmentKey & segment_key;
47533  HPS::MarkerKit & marker_kit;
47534  };
47535 
47537  {
47539  MarkerAttributeImportEvent & operator=(MarkerAttributeImportEvent const &);
47540  public:
47541  MarkerAttributeImportEvent();
47542  virtual ~MarkerAttributeImportEvent();
47543  MarkerAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::MarkerAttributeKit & in_marker_attribute_kit);
47544 
47545  HPS::SegmentKey & segment_key;
47546  HPS::MarkerAttributeKit & marker_attribute_kit;
47547  };
47548 
47549  class HPS_API MaterialImportEvent : public ImportEvent
47550  {
47552  MaterialImportEvent & operator=(MaterialImportEvent const &);
47553  public:
47554  MaterialImportEvent();
47555  virtual ~MaterialImportEvent();
47556  MaterialImportEvent(HPS::Key & in_key, HPS::MaterialMappingKit & in_material_mapping_kit);
47557 
47558  HPS::Key & key;
47559  HPS::MaterialMappingKit & material_mapping_kit;
47560  };
47561 
47563  {
47565  MaterialPaletteDefinitionImportEvent & operator=(MaterialPaletteDefinitionImportEvent const &);
47566  public:
47567  MaterialPaletteDefinitionImportEvent();
47568  virtual ~MaterialPaletteDefinitionImportEvent();
47569  MaterialPaletteDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
47570 
47571  HPS::PortfolioKey & portfolio_key;
47572  HPS::UTF8 name;
47573  HPS::MaterialKitArray & material_mapping_kit_array;
47574  };
47575 
47577  {
47579  MaterialPaletteImportEvent & operator=(MaterialPaletteImportEvent const &);
47580  public:
47581  MaterialPaletteImportEvent();
47582  virtual ~MaterialPaletteImportEvent();
47583  MaterialPaletteImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name);
47584 
47585  HPS::SegmentKey & segment_key;
47586  HPS::UTF8 name;
47587  };
47588 
47589  class HPS_API MatrixImportEvent : public ImportEvent
47590  {
47592  MatrixImportEvent & operator=(MatrixImportEvent const &);
47593  public:
47594  MatrixImportEvent();
47595  virtual ~MatrixImportEvent();
47596  MatrixImportEvent(HPS::Key & in_key, HPS::MatrixKit & in_matrix_kit);
47597 
47598  HPS::Key & key;
47599  HPS::MatrixKit & matrix_kit;
47600  };
47601 
47602  class HPS_API MeshImportEvent : public ImportEvent
47603  {
47605  MeshImportEvent & operator=(MeshImportEvent const &);
47606  public:
47607  MeshImportEvent();
47608  virtual ~MeshImportEvent();
47609  MeshImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit);
47610 
47611  HPS::SegmentKey & segment_key;
47612  HPS::MeshKit & mesh_kit;
47613  };
47614 
47615  class HPS_API MeshInstanceImportEvent : public ImportEvent
47616  {
47618  MeshInstanceImportEvent & operator=(MeshInstanceImportEvent const &);
47619  public:
47620  MeshInstanceImportEvent();
47621  virtual ~MeshInstanceImportEvent();
47622  MeshInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::MeshKit & in_mesh_kit, HPS::MatrixKit & in_modelling_matrix);
47623 
47624  HPS::SegmentKey & segment_key;
47625  HPS::MeshKit & mesh_kit;
47626  HPS::MatrixKit & modelling_matrix;
47627  };
47628 
47630  {
47632  NamedStyleDefinitionImportEvent & operator=(NamedStyleDefinitionImportEvent const &);
47633  public:
47634  NamedStyleDefinitionImportEvent();
47635  virtual ~NamedStyleDefinitionImportEvent();
47636  NamedStyleDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::SegmentKey & in_style_key);
47637 
47638  HPS::PortfolioKey & portfolio_key;
47639  HPS::UTF8 name;
47640  HPS::SegmentKey & style_key;
47641  };
47642 
47643  class HPS_API NamedStyleImportEvent : public ImportEvent
47644  {
47646  NamedStyleImportEvent & operator=(NamedStyleImportEvent const &);
47647  public:
47648  NamedStyleImportEvent();
47649  virtual ~NamedStyleImportEvent();
47650  NamedStyleImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
47651 
47652  HPS::SegmentKey & segment_key;
47653  HPS::UTF8 name;
47654  HPS::ConditionalExpression & condition;
47655  HPS::AttributeLockTypeArray filter_types;
47656  };
47657 
47658  class HPS_API NURBSCurveImportEvent : public ImportEvent
47659  {
47661  NURBSCurveImportEvent & operator=(NURBSCurveImportEvent const &);
47662  public:
47663  NURBSCurveImportEvent();
47664  virtual ~NURBSCurveImportEvent();
47665  NURBSCurveImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSCurveKit & in_nurbs_curve_kit);
47666 
47667  HPS::SegmentKey & segment_key;
47668  HPS::NURBSCurveKit & nurbs_curve_kit;
47669  };
47670 
47671  class HPS_API NURBSSurfaceImportEvent : public ImportEvent
47672  {
47674  NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent const &);
47675  public:
47676  NURBSSurfaceImportEvent();
47677  virtual ~NURBSSurfaceImportEvent();
47678  NURBSSurfaceImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceKit & in_nurbs_surface_kit);
47679 
47680  HPS::SegmentKey & segment_key;
47681  HPS::NURBSSurfaceKit & nurbs_surface_kit;
47682  };
47683 
47685  {
47687  NURBSSurfaceAttributeImportEvent & operator=(NURBSSurfaceAttributeImportEvent const &);
47688  public:
47689  NURBSSurfaceAttributeImportEvent();
47690  virtual ~NURBSSurfaceAttributeImportEvent();
47691  NURBSSurfaceAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::NURBSSurfaceAttributeKit & in_nurbs_surface_attribute_kit);
47692 
47693  HPS::SegmentKey & segment_key;
47694  HPS::NURBSSurfaceAttributeKit & nurbs_surface_attribute_kit;
47695  };
47696 
47697  class HPS_API PerformanceImportEvent : public ImportEvent
47698  {
47700  PerformanceImportEvent & operator=(PerformanceImportEvent const &);
47701  public:
47702  PerformanceImportEvent();
47703  virtual ~PerformanceImportEvent();
47704  PerformanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::PerformanceKit & in_performance_kit);
47705 
47706  HPS::SegmentKey & segment_key;
47707  HPS::PerformanceKit & performance_kit;
47708  };
47709 
47710  class HPS_API PolygonImportEvent : public ImportEvent
47711  {
47713  PolygonImportEvent & operator=(PolygonImportEvent const &);
47714  public:
47715  PolygonImportEvent();
47716  virtual ~PolygonImportEvent();
47717  PolygonImportEvent(HPS::SegmentKey & in_segment_key, HPS::PolygonKit & in_polygon_kit);
47718 
47719  HPS::SegmentKey & segment_key;
47720  HPS::PolygonKit & polygon_kit;
47721  };
47722 
47723  class HPS_API PriorityImportEvent : public ImportEvent
47724  {
47726  PriorityImportEvent & operator=(PriorityImportEvent const &);
47727  public:
47728  PriorityImportEvent();
47729  virtual ~PriorityImportEvent();
47730  PriorityImportEvent(HPS::Key & in_key, int in_priority);
47731 
47732  HPS::Key & key;
47733  int priority;
47734  };
47735 
47737  {
47739  ReferenceGeometryImportEvent & operator=(ReferenceGeometryImportEvent const &);
47740  public:
47741  ReferenceGeometryImportEvent();
47742  virtual ~ReferenceGeometryImportEvent();
47743  ReferenceGeometryImportEvent(HPS::SegmentKey & in_segment_key, HPS::Key & in_reference_geometry_key, HPS::ConditionalExpression & in_conditional);
47744 
47745  HPS::SegmentKey & segment_key;
47746  HPS::Key & reference_geometry_key;
47747  HPS::ConditionalExpression & condition;
47748  };
47749 
47750  class HPS_API SegmentImportEvent : public ImportEvent
47751  {
47753  SegmentImportEvent & operator=(SegmentImportEvent const &);
47754  public:
47755  SegmentImportEvent();
47756  virtual ~SegmentImportEvent();
47757  SegmentImportEvent(HPS::SegmentKey & in_segment_key, const char * in_name);
47758 
47759  HPS::SegmentKey & segment_key;
47760  HPS::UTF8 name;
47761  };
47762 
47763  class HPS_API SelectabilityImportEvent : public ImportEvent
47764  {
47766  SelectabilityImportEvent & operator=(SelectabilityImportEvent const &);
47767  public:
47768  SelectabilityImportEvent();
47769  virtual ~SelectabilityImportEvent();
47770  SelectabilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::SelectabilityKit & in_selectability_kit);
47771 
47772  HPS::SegmentKey & segment_key;
47773  HPS::SelectabilityKit & selectability_kit;
47774  };
47775 
47777  {
47779  ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent const &);
47780  public:
47781  ShaderDefinitionImportEvent();
47782  virtual ~ShaderDefinitionImportEvent();
47783  ShaderDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name, HPS::ShaderKit & in_shader_kit);
47784 
47785  HPS::PortfolioKey & portfolio_key;
47786  UTF8 name;
47787  HPS::ShaderKit & shader_kit;
47788  };
47789 
47790  class HPS_API ShellImportEvent : public ImportEvent
47791  {
47793  ShellImportEvent & operator=(ShellImportEvent const &);
47794  public:
47795  ShellImportEvent();
47796  virtual ~ShellImportEvent();
47797  ShellImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit);
47798 
47799  HPS::SegmentKey & segment_key;
47800  HPS::ShellKit & shell_kit;
47801  };
47802 
47803  class HPS_API ShellInstanceImportEvent : public ImportEvent
47804  {
47806  ShellInstanceImportEvent & operator=(ShellInstanceImportEvent const &);
47807  public:
47808  ShellInstanceImportEvent();
47809  virtual ~ShellInstanceImportEvent();
47810  ShellInstanceImportEvent(HPS::SegmentKey & in_segment_key, HPS::ShellKit & in_shell_kit, HPS::MatrixKit & in_modelling_matrix);
47811 
47812  HPS::SegmentKey & segment_key;
47813  HPS::ShellKit & shell_kit;
47814  HPS::MatrixKit & modelling_matrix;
47815  };
47816 
47817  class HPS_API SphereImportEvent : public ImportEvent
47818  {
47820  SphereImportEvent & operator=(SphereImportEvent const &);
47821  public:
47822  SphereImportEvent();
47823  virtual ~SphereImportEvent();
47824  SphereImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereKit & in_sphere_kit);
47825 
47826  HPS::SegmentKey & segment_key;
47827  HPS::SphereKit & sphere_kit;
47828  };
47829 
47831  {
47833  SphereAttributeImportEvent & operator=(SphereAttributeImportEvent const &);
47834  public:
47835  SphereAttributeImportEvent();
47836  virtual ~SphereAttributeImportEvent();
47837  SphereAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::SphereAttributeKit & in_sphere_attribute_kit);
47838 
47839  HPS::SegmentKey & segment_key;
47840  HPS::SphereAttributeKit & sphere_attribute_kit;
47841  };
47842 
47843  class HPS_API SpotlightImportEvent : public ImportEvent
47844  {
47846  SpotlightImportEvent & operator=(SpotlightImportEvent const &);
47847  public:
47848  SpotlightImportEvent();
47849  virtual ~SpotlightImportEvent();
47850  SpotlightImportEvent(HPS::SegmentKey & in_segment_key, HPS::SpotlightKit & in_spotlight_kit);
47851 
47852  HPS::SegmentKey & segment_key;
47853  HPS::SpotlightKit & spotlight_kit;
47854  };
47855 
47856  class HPS_API StyleSegmentImportEvent : public ImportEvent
47857  {
47859  StyleSegmentImportEvent & operator=(StyleSegmentImportEvent const &);
47860  public:
47861  StyleSegmentImportEvent();
47862  virtual ~StyleSegmentImportEvent();
47863  StyleSegmentImportEvent(HPS::SegmentKey & in_segment_key, HPS::SegmentKey & in_style_segment_key, HPS::ConditionalExpression & in_conditional, HPS::AttributeLockTypeArray && in_filter_types);
47864 
47865  HPS::SegmentKey & segment_key;
47866  HPS::SegmentKey & style_segment_key;
47867  HPS::ConditionalExpression & condition;
47868  HPS::AttributeLockTypeArray filter_types;
47869  };
47870 
47871  class HPS_API TextImportEvent : public ImportEvent
47872  {
47874  TextImportEvent & operator=(TextImportEvent const &);
47875  public:
47876  TextImportEvent();
47877  virtual ~TextImportEvent();
47878  TextImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextKit & in_text_kit);
47879 
47880  HPS::SegmentKey & segment_key;
47881  HPS::TextKit & text_kit;
47882  };
47883 
47884  class HPS_API TextAttributeImportEvent : public ImportEvent
47885  {
47887  TextAttributeImportEvent & operator=(TextAttributeImportEvent const &);
47888  public:
47889  TextAttributeImportEvent();
47890  virtual ~TextAttributeImportEvent();
47891  TextAttributeImportEvent(HPS::TextKey & in_text_key, HPS::TextAttributeKit & in_text_attribute_kit);
47892  TextAttributeImportEvent(HPS::SegmentKey & in_segment_key, HPS::TextAttributeKit & in_text_attribute_kit);
47893 
47894  HPS::Key & key;
47895  HPS::TextAttributeKit & text_attribute_kit;
47896  };
47897 
47899  {
47901  TextureDefinitionImportEvent & operator=(TextureDefinitionImportEvent const &);
47902  public:
47903  TextureDefinitionImportEvent();
47904  virtual ~TextureDefinitionImportEvent();
47905  TextureDefinitionImportEvent(HPS::PortfolioKey & in_portfolio_key, const char * in_name,
47906  HPS::ImageDefinition & in_source_definition, HPS::TextureOptionsKit & in_texture_kit);
47907 
47908  HPS::PortfolioKey & portfolio_key;
47909  UTF8 name;
47910  HPS::ImageDefinition & source_definition;
47911  HPS::TextureOptionsKit & texture_kit;
47912  };
47913 
47914  class HPS_API TransformMaskImportEvent : public ImportEvent
47915  {
47917  TransformMaskImportEvent & operator=(TransformMaskImportEvent const &);
47918  public:
47919  TransformMaskImportEvent();
47920  virtual ~TransformMaskImportEvent();
47921  TransformMaskImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransformMaskKit & in_transform_mask_kit);
47922 
47923  HPS::SegmentKey & segment_key;
47924  HPS::TransformMaskKit & transform_mask_kit;
47925  };
47926 
47927  class HPS_API TransparencyImportEvent : public ImportEvent
47928  {
47930  TransparencyImportEvent & operator=(TransparencyImportEvent const &);
47931  public:
47932  TransparencyImportEvent();
47933  virtual ~TransparencyImportEvent();
47934  TransparencyImportEvent(HPS::SegmentKey & in_segment_key, HPS::TransparencyKit & in_transparency_kit);
47935 
47936  HPS::SegmentKey & segment_key;
47937  HPS::TransparencyKit & transparency_kit;
47938  };
47939 
47940  class HPS_API SubwindowImportEvent : public ImportEvent
47941  {
47943  SubwindowImportEvent & operator=(SubwindowImportEvent const &);
47944  public:
47945  SubwindowImportEvent();
47946  virtual ~SubwindowImportEvent();
47947  SubwindowImportEvent(HPS::SegmentKey & in_segment_key, HPS::SubwindowKit & in_subwindow_kit);
47948 
47949  HPS::SegmentKey & segment_key;
47950  HPS::SubwindowKit & subwindow_kit;
47951  };
47952 
47954  class HPS_API NonDBUserDataImportEvent : public ImportEvent
47955  {
47957  NonDBUserDataImportEvent & operator=(NonDBUserDataImportEvent const &);
47958  public:
47959  NonDBUserDataImportEvent() {}
47960  virtual ~NonDBUserDataImportEvent();
47961  NonDBUserDataImportEvent(size_t in_count, HPS::byte const in_data[]);
47962 
47964  HPS::ByteArray user_data;
47965  };
47966 
47968  class HPS_API UserDataImportEvent : public ImportEvent
47969  {
47971  UserDataImportEvent & operator=(UserDataImportEvent const &);
47972  public:
47973  virtual ~UserDataImportEvent();
47974  UserDataImportEvent();
47975  UserDataImportEvent(HPS::Key & in_key, intptr_t in_index, size_t in_count, HPS::byte const in_data[]);
47976 
47977  HPS::Key key;
47978  intptr_t index;
47979 
47981  HPS::ByteArray user_data;
47982  };
47983 
47984  class HPS_API VisibilityImportEvent : public ImportEvent
47985  {
47987  VisibilityImportEvent & operator=(VisibilityImportEvent const &);
47988  public:
47989  VisibilityImportEvent();
47990  virtual ~VisibilityImportEvent();
47991  VisibilityImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisibilityKit & in_visibility_kit);
47992 
47993  HPS::SegmentKey & segment_key;
47994  HPS::VisibilityKit & visibility_kit;
47995  };
47996 
47997  class HPS_API VisualEffectsImportEvent : public ImportEvent
47998  {
48000  VisualEffectsImportEvent & operator=(VisualEffectsImportEvent const &);
48001  public:
48002  VisualEffectsImportEvent();
48003  virtual ~VisualEffectsImportEvent();
48004  VisualEffectsImportEvent(HPS::SegmentKey & in_segment_key, HPS::VisualEffectsKit & in_visual_effects_kit);
48005 
48006  HPS::SegmentKey & segment_key;
48007  HPS::VisualEffectsKit & visual_effects_kit;
48008  };
48009 
48011 
48012 
48014  class HPS_API ImportOptionsKit : public Kit
48015  {
48016  public:
48018  ImportOptionsKit();
48019 
48022  ImportOptionsKit(ImportOptionsKit const & in_kit);
48023 
48027  ImportOptionsKit(ImportOptionsKit && in_that);
48028 
48032  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
48033 
48034  virtual ~ImportOptionsKit();
48035 
48036  HPS::Type ObjectType() const { return HPS::Type::StreamImportOptionsKit; };
48037 
48040  void Set(ImportOptionsKit const & in_kit);
48041 
48044  void Show(ImportOptionsKit & out_kit) const;
48045 
48049  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
48050 
48053  bool Empty() const;
48054 
48058  bool Equals(ImportOptionsKit const & in_kit) const;
48059 
48063  bool operator==(ImportOptionsKit const & in_kit) const;
48064 
48068  bool operator!=(ImportOptionsKit const & in_kit) const;
48069 
48072  ImportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
48073 
48076  ImportOptionsKit & UnsetToolkit();
48077 
48081  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
48082 
48087  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
48088 
48091  ImportOptionsKit & UnsetSegment();
48092 
48096  bool ShowSegment(SegmentKey & out_segment) const;
48097 
48102  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
48103 
48106  ImportOptionsKit & UnsetAlternateRoot();
48107 
48111  bool ShowAlternateRoot(SegmentKey & out_segment) const;
48112 
48117  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
48118 
48121  ImportOptionsKit & UnsetPortfolio();
48122 
48126  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
48127 
48130  ImportOptionsKit & UnsetEverything();
48131 
48136  ImportOptionsKit & SetEventHandler(HPS::Stream::ImportEventHandler & in_handler, intptr_t in_type);
48137 
48141  ImportOptionsKit & UnsetEventHandler(intptr_t in_type);
48142 
48145  ImportOptionsKit & UnsetEventHandlers();
48146  };
48147 
48149  class HPS_API ImportResultsKit : public Kit
48150  {
48151  public:
48153  ImportResultsKit();
48154 
48157  ImportResultsKit(ImportResultsKit const & in_kit);
48158 
48162  ImportResultsKit(ImportResultsKit && in_that);
48163 
48167  ImportResultsKit & operator=(ImportResultsKit && in_that);
48168 
48169  virtual ~ImportResultsKit();
48170 
48171  HPS::Type ObjectType() const { return HPS::Type::StreamImportResultsKit; };
48172 
48175  void Set(ImportResultsKit const & in_kit);
48176 
48179  void Show(ImportResultsKit & out_kit) const;
48180 
48184  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
48185 
48188  bool Empty() const;
48189 
48193  bool Equals(ImportResultsKit const & in_kit) const;
48194 
48198  bool operator==(ImportResultsKit const & in_kit) const;
48199 
48203  bool operator!=(ImportResultsKit const & in_kit) const;
48204 
48209  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
48210 
48214  ImportResultsKit & UnsetSegment();
48215 
48220  bool ShowSegment(SegmentKey & out_segment) const;
48221 
48226  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
48227 
48231  ImportResultsKit & UnsetAlternateRoot();
48232 
48238  bool ShowAlternateRoot(SegmentKey & out_segment) const;
48239 
48244  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
48245 
48249  ImportResultsKit & UnsetPortfolio();
48250 
48256  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
48257 
48262  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
48263 
48267  ImportResultsKit & UnsetDefaultCamera();
48268 
48273  bool ShowDefaultCamera(CameraKit & out_camera) const;
48274 
48275 
48281  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
48282 
48286  ImportResultsKit & UnsetAlternateCameras();
48287 
48292  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
48293 
48294 
48297  ImportResultsKit & UnsetEverything();
48298  };
48299 
48301  class HPS_API ExportOptionsKit : public Kit
48302  {
48303  public:
48305  ExportOptionsKit();
48306 
48309  ExportOptionsKit(ExportOptionsKit const & in_kit);
48310 
48314  ExportOptionsKit(ExportOptionsKit && in_that);
48315 
48319  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
48320 
48324  static ExportOptionsKit GetDefault();
48325 
48326  virtual ~ExportOptionsKit();
48327 
48328  HPS::Type ObjectType() const { return HPS::Type::StreamExportOptionsKit; };
48329 
48332  void Set(ExportOptionsKit const & in_kit);
48333 
48336  void Show(ExportOptionsKit & out_kit) const;
48337 
48341  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
48342 
48345  bool Empty() const;
48346 
48350  bool Equals(ExportOptionsKit const & in_kit) const;
48351 
48355  bool operator==(ExportOptionsKit const & in_kit) const;
48356 
48360  bool operator!=(ExportOptionsKit const & in_kit) const;
48361 
48364  ExportOptionsKit & SetToolkit(Toolkit const & in_toolkit);
48365 
48369  ExportOptionsKit & SetDefaultCamera(CameraKit const & in_camera);
48370 
48378  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
48379 
48387  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
48388 
48394  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
48395 
48403  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
48404 
48412  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
48413 
48419  ExportOptionsKit & SetConnectivityCompression(bool in_state);
48420 
48426  ExportOptionsKit & SetSerializeTristrips(bool in_state);
48427 
48436  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
48437 
48440  ExportOptionsKit & UnsetToolkit();
48441 
48444  ExportOptionsKit & UnsetDefaultCamera();
48445 
48448  ExportOptionsKit & UnsetVertexCompression();
48449 
48452  ExportOptionsKit & UnsetNormalCompression();
48453 
48456  ExportOptionsKit & UnsetParameterCompression();
48457 
48460  ExportOptionsKit & UnsetColorCompression();
48461 
48464  ExportOptionsKit & UnsetIndexCompression();
48465 
48468  ExportOptionsKit & UnsetConnectivityCompression();
48469 
48472  ExportOptionsKit & UnsetImageCompression();
48473 
48476  ExportOptionsKit & UnsetSerializeTristrips();
48477 
48480  ExportOptionsKit & UnsetEverything();
48481 
48485  bool ShowToolkit(HPS::Stream::Toolkit & out_toolkit) const;
48486 
48490  bool ShowDefaultCamera(CameraKit & out_camera) const;
48491 
48496  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
48497 
48502  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
48503 
48508  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
48509 
48514  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
48515 
48520  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
48521 
48525  bool ShowConnectivityCompression(bool & out_state) const;
48526 
48531  bool ShowImageCompression(bool & out_state, float & out_quality) const;
48532 
48536  bool ShowSerializeTristrips(bool & out_state) const;
48537 
48542  ExportOptionsKit & SetEventHandler(HPS::Stream::ExportEventHandler & in_handler, intptr_t in_type);
48543 
48547  ExportOptionsKit & UnsetEventHandler(intptr_t in_type);
48548 
48551  ExportOptionsKit & UnsetEventHandlers();
48552  };
48553 
48556  class HPS_API ImportNotifier : public IONotifier
48557  {
48558  public:
48560  ImportNotifier();
48561 
48564  ImportNotifier(ImportNotifier const & in_that);
48565 
48570  ImportNotifier(IONotifier const & in_that);
48571 
48575  ImportNotifier(ImportNotifier && in_that);
48576 
48580  ImportNotifier & operator=(ImportNotifier && in_that);
48581 
48582  virtual ~ImportNotifier();
48583 
48584  HPS::Type ObjectType() const {return HPS::Type::StreamImportNotifier;};
48585 
48589  ImportNotifier & operator=(ImportNotifier const & in_that);
48590 
48593  void Assign(ImportNotifier const & in_that);
48594 
48598  ImportResultsKit GetResults() const;
48599  };
48600 
48603  class HPS_API ExportNotifier : public IONotifier
48604  {
48605  public:
48607  ExportNotifier();
48608 
48611  ExportNotifier(ExportNotifier const & in_that);
48612 
48617  ExportNotifier(IONotifier const & in_that);
48618 
48622  ExportNotifier(ExportNotifier && in_that);
48623 
48627  ExportNotifier & operator=(ExportNotifier && in_that);
48628 
48629  virtual ~ExportNotifier();
48630 
48631  HPS::Type ObjectType() const {return HPS::Type::StreamExportNotifier;};
48632 
48636  ExportNotifier & operator=(ExportNotifier const & in_that);
48637 
48640  void Assign(ExportNotifier const & in_that);
48641  };
48642 
48643 
48645  class HPS_API File
48646  {
48647  public:
48653  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
48654 
48660  static ImportNotifier Import(ByteArrayArray const & in_hsf_buffers, ImportOptionsKit const & in_options);
48661 
48668  static ExportNotifier Export(char const * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
48669 
48676  static ExportNotifier Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
48677 
48678  private:
48680  File();
48681  };
48682 private:
48684  Stream();
48685 };
48686 
48690 
48695 class HPS_API Hardcopy
48696 {
48697 public:
48698 
48700  enum class SizeUnits : uint32_t
48701  {
48702  Centimeters,
48703  Inches,
48704  };
48705 
48707  enum class ResolutionUnits : uint32_t
48708  {
48709  DPCM,
48710  DPI,
48711  DotsPerCentimeter = DPCM,
48712  DotsPerInch = DPI,
48713  };
48714 
48716  class HPS_API File
48717  {
48718  public:
48719 
48721  class HPS_API ExportOptionsKit : public Kit
48722  {
48723  public:
48725  ExportOptionsKit();
48726 
48729  ExportOptionsKit(ExportOptionsKit const & in_kit);
48730 
48734  ExportOptionsKit(ExportOptionsKit && in_that);
48735 
48739  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
48740 
48741  virtual ~ExportOptionsKit();
48742 
48743  HPS::Type ObjectType() const { return HPS::Type::HardcopyExportOptionsKit; };
48744 
48747  void Set(ExportOptionsKit const & in_kit);
48748 
48751  void Show(ExportOptionsKit & out_kit) const;
48752 
48756  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
48757 
48760  bool Empty() const;
48761 
48765  bool Equals(ExportOptionsKit const & in_kit) const;
48766 
48770  bool operator==(ExportOptionsKit const & in_kit) const;
48771 
48775  bool operator!=(ExportOptionsKit const & in_kit) const;
48776 
48777 
48778 
48779 
48785  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
48786 
48794  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
48795 
48798  ExportOptionsKit & UnsetSize();
48799 
48800 
48801 
48807  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
48808 
48815  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
48816 
48819  ExportOptionsKit & UnsetResolution();
48820 
48821 
48822 
48826  bool ShowWYSIWYG(bool & out_onoff) const;
48827 
48839  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
48840 
48843  ExportOptionsKit & UnsetWYSIWYG();
48844 
48849  bool ShowScale(float & out_scale, HPS::Hardcopy::SizeUnits & out_units) const;
48850 
48860  ExportOptionsKit & SetScale(float in_scale, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
48861 
48864  ExportOptionsKit & UnsetScale();
48865 
48866 
48869  ExportOptionsKit & UnsetEverything();
48870 
48871 
48875  static ExportOptionsKit GetDefault();
48876  };
48877 
48879  enum class Driver : uint32_t
48880  {
48881  PDF,
48882  Postscript
48883  };
48884 
48890  static IOResult Export(char const * in_filename, Driver in_driver_type, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
48891  private:
48892  File();
48893  };
48894 
48895 #ifdef _MSC_VER
48896  class HPS_API GDI
48897  {
48898  public:
48899 
48901  class HPS_API ExportOptionsKit : public Kit
48902  {
48903  public:
48905  ExportOptionsKit();
48906 
48909  ExportOptionsKit(ExportOptionsKit const & in_kit);
48910 
48914  ExportOptionsKit(ExportOptionsKit && in_that);
48915 
48919  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
48920 
48921  virtual ~ExportOptionsKit();
48922 
48923  HPS::Type ObjectType() const { return HPS::Type::HardcopyGDIExportOptionsKit; };
48924 
48927  void Set(ExportOptionsKit const & in_kit);
48928 
48931  void Show(ExportOptionsKit & out_kit) const;
48932 
48936  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
48937 
48940  bool Empty() const;
48941 
48945  bool Equals(ExportOptionsKit const & in_kit) const;
48946 
48950  bool operator==(ExportOptionsKit const & in_kit) const;
48951 
48955  bool operator!=(ExportOptionsKit const & in_kit) const;
48956 
48957 
48962  bool ShowSize(float & out_width, float & out_height) const;
48963 
48968  ExportOptionsKit & SetSize(float in_width, float in_height);
48969 
48972  ExportOptionsKit & UnsetSize();
48973 
48974 
48978  bool ShowResolution(float & out_resolution) const;
48979 
48983  ExportOptionsKit & SetResolution(float in_resolution);
48984 
48987  ExportOptionsKit & UnsetResolution();
48988 
48989 
48990 
48991 
48994  bool ShowWYSIWYG(bool & out_onoff) const;
48995 
48999  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
49000 
49003  ExportOptionsKit & UnsetWYSIWYG();
49004 
49009  bool ShowScale(float & out_scale, HPS::Hardcopy::SizeUnits & out_units) const;
49010 
49020  ExportOptionsKit & SetScale(float in_scale, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
49021 
49024  ExportOptionsKit & UnsetScale();
49025 
49026 
49029  ExportOptionsKit & UnsetEverything();
49030  };
49031 
49038  static IOResult Export(intptr_t in_hdc, intptr_t in_attribdc, HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
49039 
49044  static IOResult ExportClipboard(HPS::WindowKey const & in_window, ExportOptionsKit const & in_options);
49045 
49051  static IOResult ExportEMF(char const * in_filename, WindowKey const & in_window, ExportOptionsKit const & in_options);
49052 
49053  private:
49054  GDI();
49055  };
49056 #endif
49057 
49058 private:
49059  Hardcopy();
49060 };
49061 
49065 
49067 class HPS_API OBJ
49068 {
49069 public:
49070 
49072  class HPS_API ImportOptionsKit : public Kit
49073  {
49074  public:
49076  ImportOptionsKit();
49077 
49080  ImportOptionsKit(ImportOptionsKit const & in_kit);
49081 
49085  ImportOptionsKit(ImportOptionsKit && in_that);
49086 
49090  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
49091 
49092  virtual ~ImportOptionsKit();
49093 
49094  HPS::Type ObjectType() const { return HPS::Type::OBJImportOptionsKit; };
49095 
49098  void Set(ImportOptionsKit const & in_kit);
49099 
49102  void Show(ImportOptionsKit & out_kit) const;
49103 
49107  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
49108 
49111  bool Empty() const;
49112 
49116  bool Equals(ImportOptionsKit const & in_kit) const;
49117 
49121  bool operator==(ImportOptionsKit const & in_kit) const;
49122 
49126  bool operator!=(ImportOptionsKit const & in_kit) const;
49127 
49132  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
49133 
49136  ImportOptionsKit & UnsetSegment();
49137 
49141  bool ShowSegment(SegmentKey & out_segment) const;
49142 
49147  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
49148 
49151  ImportOptionsKit & UnsetPortfolio();
49152 
49156  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
49157 
49163  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
49164 
49167  ImportOptionsKit & UnsetHandedness();
49168 
49172  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
49173 
49176  ImportOptionsKit & UnsetEverything();
49177  };
49178 
49180  class HPS_API ImportResultsKit : public Kit
49181  {
49182  public:
49184  ImportResultsKit();
49185 
49188  ImportResultsKit(ImportResultsKit const & in_kit);
49189 
49193  ImportResultsKit(ImportResultsKit && in_that);
49194 
49198  ImportResultsKit & operator=(ImportResultsKit && in_that);
49199 
49200  virtual ~ImportResultsKit();
49201 
49202  HPS::Type ObjectType() const { return HPS::Type::OBJImportResultsKit; };
49203 
49206  void Set(ImportResultsKit const & in_kit);
49207 
49210  void Show(ImportResultsKit & out_kit) const;
49211 
49215  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
49216 
49219  bool Empty() const;
49220 
49224  bool Equals(ImportResultsKit const & in_kit) const;
49225 
49229  bool operator==(ImportResultsKit const & in_kit) const;
49230 
49234  bool operator!=(ImportResultsKit const & in_kit) const;
49235 
49240  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
49241 
49245  ImportResultsKit & UnsetSegment();
49246 
49251  bool ShowSegment(SegmentKey & out_segment) const;
49252 
49257  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
49258 
49262  ImportResultsKit & UnsetPortfolio();
49263 
49269  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
49270 
49275  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
49276 
49280  ImportResultsKit & UnsetHandedness();
49281 
49286  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
49287 
49290  ImportResultsKit & UnsetEverything();
49291  };
49292 
49295  class HPS_API ImportNotifier : public IONotifier
49296  {
49297  public:
49299  ImportNotifier();
49300 
49303  ImportNotifier(ImportNotifier const & in_that);
49304 
49309  ImportNotifier(IONotifier const & in_that);
49310 
49314  ImportNotifier(ImportNotifier && in_that);
49315 
49319  ImportNotifier & operator=(ImportNotifier && in_that);
49320 
49321  virtual ~ImportNotifier();
49322 
49323  HPS::Type ObjectType() const {return HPS::Type::OBJImportNotifier;};
49324 
49328  ImportNotifier & operator=(ImportNotifier const & in_that);
49329 
49332  void Assign(ImportNotifier const & in_that);
49333 
49337  ImportResultsKit GetResults() const;
49338  };
49339 
49340 
49342  class HPS_API File
49343  {
49344  public:
49350  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
49351 
49352  private:
49354  File();
49355  };
49356 private:
49358  OBJ();
49359 };
49360 
49364 
49366 class HPS_API STL
49367 {
49368 public:
49369 
49371  class HPS_API ImportOptionsKit : public Kit
49372  {
49373  public:
49375  ImportOptionsKit();
49376 
49379  ImportOptionsKit(ImportOptionsKit const & in_kit);
49380 
49384  ImportOptionsKit(ImportOptionsKit && in_that);
49385 
49389  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
49390 
49391  virtual ~ImportOptionsKit();
49392 
49393  HPS::Type ObjectType() const { return HPS::Type::STLImportOptionsKit; };
49394 
49397  void Set(ImportOptionsKit const & in_kit);
49398 
49401  void Show(ImportOptionsKit & out_kit) const;
49402 
49406  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
49407 
49410  bool Empty() const;
49411 
49415  bool Equals(ImportOptionsKit const & in_kit) const;
49416 
49420  bool operator==(ImportOptionsKit const & in_kit) const;
49421 
49425  bool operator!=(ImportOptionsKit const & in_kit) const;
49426 
49430  static ImportOptionsKit GetDefault();
49431 
49436  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
49437 
49445  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
49446 
49453  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
49454 
49455 
49458  ImportOptionsKit & UnsetSegment();
49459 
49462  ImportOptionsKit & UnsetOptimization();
49463 
49466  ImportOptionsKit & UnsetEverything();
49467 
49468 
49472  bool ShowSegment(SegmentKey & out_segment) const;
49473 
49478  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
49479  };
49480 
49482  class HPS_API ImportResultsKit : public Kit
49483  {
49484  public:
49486  ImportResultsKit();
49487 
49490  ImportResultsKit(ImportResultsKit const & in_kit);
49491 
49495  ImportResultsKit(ImportResultsKit && in_that);
49496 
49500  ImportResultsKit & operator=(ImportResultsKit && in_that);
49501 
49502  virtual ~ImportResultsKit();
49503 
49504  HPS::Type ObjectType() const { return HPS::Type::STLImportResultsKit; };
49505 
49508  void Set(ImportResultsKit const & in_kit);
49509 
49512  void Show(ImportResultsKit & out_kit) const;
49513 
49517  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
49518 
49521  bool Empty() const;
49522 
49526  bool Equals(ImportResultsKit const & in_kit) const;
49527 
49531  bool operator==(ImportResultsKit const & in_kit) const;
49532 
49536  bool operator!=(ImportResultsKit const & in_kit) const;
49537 
49542  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
49543 
49547  ImportResultsKit & UnsetSegment();
49548 
49553  bool ShowSegment(SegmentKey & out_segment) const;
49554 
49557  ImportResultsKit & UnsetEverything();
49558  };
49559 
49562  class HPS_API ImportNotifier : public IONotifier
49563  {
49564  public:
49566  ImportNotifier();
49567 
49570  ImportNotifier(ImportNotifier const & in_that);
49571 
49576  ImportNotifier(IONotifier const & in_that);
49577 
49581  ImportNotifier(ImportNotifier && in_that);
49582 
49586  ImportNotifier & operator=(ImportNotifier && in_that);
49587 
49588  virtual ~ImportNotifier();
49589 
49590  HPS::Type ObjectType() const {return HPS::Type::STLImportNotifier;};
49591 
49595  ImportNotifier & operator=(ImportNotifier const & in_that);
49596 
49599  void Assign(ImportNotifier const & in_that);
49600 
49604  ImportResultsKit GetResults() const;
49605  };
49606 
49607 
49609  class HPS_API File
49610  {
49611  public:
49617  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
49618 
49619  private:
49621  File();
49622  };
49623 private:
49625  STL();
49626 };
49627 
49628 }
49629 
49630 #ifdef _MSC_VER
49631 # pragma warning(pop)
49632 #endif
49633 
49634 #endif
49635 
49636 
HPS::Type ObjectType() const
Definition: hps.h:44139
HPS::Type ObjectType() const
Definition: hps.h:28627
bool Empty() const
Definition: hps.h:7148
CameraPoint(Point const &in_point)
Definition: hps.h:5966
HPS::Type ObjectType() const
Definition: hps.h:20558
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:46179
Definition: hps.h:3333
Definition: hps.h:6205
HPS::Type ObjectType() const
Definition: hps.h:25783
Definition: hps.h:15163
Definition: hps.h:1044
Definition: hps.h:12637
HPS::Type ObjectType() const
Definition: hps.h:18140
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:45965
HPS::Type ObjectType() const
Definition: hps.h:39322
Event(intptr_t in_channel=0)
Definition: hps.h:6319
Definition: hps.h:19272
HPS::Type ObjectType() const
Definition: hps.h:49323
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3840
HPS::ByteArray user_data
Definition: hps.h:47964
void ScrollLock(bool in_state)
Definition: hps.h:45557
float alpha
Definition: hps.h:4391
Definition: hps.h:37651
HPS::Type ObjectType() const
Definition: hps.h:38924
bool operator==(Touch const &in_that) const
Definition: hps.h:6607
void X1(bool in_state)
Definition: hps.h:45986
virtual HPS::Type Type() const
Definition: hps.h:22338
Search for all attributes, geometry, segments, includes and includers.
void RightMeta(bool in_state)
Definition: hps.h:45585
size_t statics_created_count
Number of static models that were created during the last update.
Definition: hps.h:4921
void Shift(bool in_state)
Definition: hps.h:45533
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:45122
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:4911
HPS::Type ObjectType() const
Definition: hps.h:37294
Definition: hps.h:8998
HPS::Type ObjectType() const
Definition: hps.h:23397
virtual HPS::Type Type() const
Definition: hps.h:9814
HPS::Type ObjectType() const
Definition: hps.h:25311
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:4917
HPS::Type ObjectType() const
Definition: hps.h:26057
Definition: hps.h:47090
Definition: hps.h:22125
Definition: sprk_exchange.h:44
Definition: hps.h:43948
void CapsLock(bool in_state)
Definition: hps.h:45549
HPS::Type ObjectType() const
Definition: hps.h:15952
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:45177
HPS::Type ObjectType() const
Definition: hps.h:8906
HPS::Type ObjectType() const
Definition: hps.h:29956
Definition: hps.h:47348
Event * Clone() const
Definition: hps.h:45020
Definition: hps.h:14080
Orientation
Definition: hps.h:541
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:46096
Definition: hps.h:49067
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:44808
ImportStatusEvent()
Definition: hps.h:45332
HPS::Type ObjectType() const
Definition: hps.h:23005
HPS::Type ObjectType() const
Definition: hps.h:39099
Parameterization
Definition: hps.h:938
Definition: hps.h:14686
HPS::Type ObjectType() const
Definition: hps.h:27574
Definition: hps.h:47018
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:45842
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:4916
LeaderLineSpace
Definition: hps.h:1672
HPS::Type ObjectType() const
Definition: hps.h:32359
HPS::Type ObjectType() const
Definition: hps.h:27185
HPS::Type ObjectType() const
Definition: hps.h:12277
static MouseButtons ButtonX2()
Definition: hps.h:46041
Definition: hps.h:21012
Type
Definition: hps.h:272
Fill
Definition: hps.h:1957
Search the current segment only.
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:46285
Definition: hps.h:49482
Definition: hps.h:41673
Definition: hps.h:20322
HPS::Type ObjectType() const
Definition: hps.h:41493
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5863
Definition: hps.h:47658
Transform
Definition: hps.h:1557
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6111
Behavior
Definition: hps.h:574
bool Middle() const
Definition: hps.h:45951
DisplayLists
Definition: hps.h:1087
Definition: hps.h:476
HPS::Type ObjectType() const
Definition: hps.h:46325
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2309
Modifier
Definition: hps.h:1893
Definition: hps.h:38415
HPS::Type ObjectType() const
Definition: hps.h:43126
Definition: hps.h:46187
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:9013
HPS::Type ObjectType() const
Definition: hps.h:25038
HPS::Type ObjectType() const
Definition: hps.h:38852
Definition: hps.h:9791
Overlay
Definition: hps.h:1280
HPS::Type ObjectType() const
Definition: hps.h:13481
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:4899
HPS::Type ObjectType() const
Definition: hps.h:46437
HPS::Type ObjectType() const
Definition: hps.h:21962
Definition: hps.h:47602
static ModifierKeys KeyLeftMeta()
Definition: hps.h:45684
Definition: hps.h:28203
HPS::Type ObjectType() const
Definition: hps.h:14711
InputEvent()
Definition: hps.h:45721
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5685
HPS::UTF8 text
The text for this TextInputEvent.
Definition: hps.h:45283
virtual HPS::Type Type() const
Definition: hps.h:18727
ClipSpace
Definition: hps.h:1310
virtual HPS::Type Type() const
Definition: hps.h:11856
Definition: hps.h:39541
virtual HPS::Type Type() const
Definition: hps.h:20345
Definition: hps.h:38382
bool ScrollLock() const
Definition: hps.h:45486
static MouseButtons ButtonRight()
Definition: hps.h:46029
virtual HPS::Type Type() const
Definition: hps.h:12766
HPS::Type ObjectType() const
Definition: hps.h:30843
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3947
Definition: hps.h:5725
RenderingAlgorithm
Definition: hps.h:289
Definition: hps.h:38687
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:46224
static ModifierKeys KeyMeta()
Definition: hps.h:45640
HPS::Type ObjectType() const
Definition: hps.h:38582
Definition: hps.h:1501
Definition: hps.h:25204
The clip region is specified in world coordinated.
HPS::Type ObjectType() const
Definition: hps.h:40600
Definition: hps.h:17710
HPS::Type ObjectType() const
Definition: hps.h:48631
Definition: hps.h:6788
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:45916
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3826
Definition: hps.h:38041
HPS::Type ObjectType() const
Definition: hps.h:20799
Decimation
Definition: hps.h:1004
HPS::Type ObjectType() const
Definition: hps.h:43303
Definition: hps.h:46678
Definition: hps.h:42054
HPS::Type ObjectType() const
Definition: hps.h:25236
HPS::Type ObjectType() const
Definition: hps.h:38120
Definition: hps.h:23945
HPS::Type ObjectType() const
Definition: hps.h:17829
MouseButtons()
Definition: hps.h:45911
HPS::Type ObjectType() const
Definition: hps.h:42217
Definition: hps.h:21728
Time GetTimeStamp() const
Definition: hps.h:6341
Definition: hps.h:49609
void Left(bool in_state)
Definition: hps.h:45974
HPS::Type ObjectType() const
Definition: hps.h:46783
HPS::Type ObjectType() const
Definition: hps.h:23915
NormalizedPoint(Point const &in_point)
Definition: hps.h:6016
HPS::Type ObjectType() const
Definition: hps.h:25585
Event * Clone() const
Definition: hps.h:44837
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3875
Definition: hps.h:47155
Kit(Kit &&in_that)
Definition: hps.h:5844
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:45970
Definition: hps.h:39411
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:37030
OuterConeUnits
Definition: hps.h:482
Definition: hps.h:44324
KeyboardEvent()
Definition: hps.h:46200
HPS::Type ObjectType() const
Definition: hps.h:7658
Definition: hps.h:41460
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:4068
ObjectPoint(Point const &in_point)
Definition: hps.h:5866
HPS::Type ObjectType() const
Definition: hps.h:18729
Definition: hps.h:36480
Definition: hps.h:45397
Definition: hps.h:44051
Definition: hps.h:4468
Definition: hps.h:6957
Definition: hps.h:1322
Definition: hps.h:44858
Definition: hps.h:26025
Point_3D< F > min
Definition: hps.h:3810
SizeUnits
Definition: hps.h:1713
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:45151
static ModifierKeys KeyAlt()
Definition: hps.h:45635
bool IsConsumable() const
Definition: hps.h:6344
HPS::ByteArray user_data
Definition: hps.h:47981
Definition: hps.h:1040
size_t GetHash() const
Definition: hps.h:1683
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:4900
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:46213
void RightShift(bool in_state)
Definition: hps.h:45561
HPS::Type ObjectType() const
Definition: hps.h:14105
ScreenRangePoint(Point const &in_point)
Definition: hps.h:6064
SizeUnits
Definition: hps.h:1833
virtual HPS::Type Type() const
Definition: hps.h:12140
virtual HPS::Type Type() const
Definition: hps.h:11028
Definition: hps.h:15623
Definition: hps.h:1933
virtual HPS::Type Type() const
Definition: hps.h:16842
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3863
Definition: hps.h:25479
Definition: hps.h:20535
HPS::Type ObjectType() const
Definition: hps.h:29132
HPS::Type ObjectType() const
Definition: hps.h:20347
char At(size_t in_index) const
Definition: hps.h:7191
Definition: hps.h:5828
Definition: hps.h:44125
StaticModel
Definition: hps.h:1109
Definition: hps.h:4494
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:45528
HPS::Type ObjectType() const
Definition: hps.h:38979
HPS::Type ObjectType() const
Definition: hps.h:7377
Definition: hps.h:132
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:4904
Definition: hps.h:27542
Definition: hps.h:46516
HideKeyboardEvent()
Definition: hps.h:45401
Definition: hps.h:3808
Definition: hps.h:3805
HPS::Type ObjectType() const
Definition: hps.h:18054
Definition: hps.h:19807
Definition: hps.h:7713
HPS::Type ObjectType() const
Definition: hps.h:12845
Definition: hps.h:28418
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6160
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3980
void LeftMeta(bool in_state)
Definition: hps.h:45589
static MouseButtons ButtonX1()
Definition: hps.h:46037
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:45292
Definition: hps.h:19499
Definition: hps.h:3484
Definition: hps.h:6589
void X2(bool in_state)
Definition: hps.h:45990
HPS::Type ObjectType() const
Definition: hps.h:20108
SizeUnits
Definition: hps.h:1690
HPS::Type ObjectType() const
Definition: hps.h:44659
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:4913
HPS::Type ObjectType() const
Definition: hps.h:43400
HPS::Type ObjectType() const
Definition: hps.h:15359
Definition: hps.h:15928
Definition: hps.h:2038
HPS::Type ObjectType() const
Definition: hps.h:36513
ToleranceUnits
Definition: hps.h:1755
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:46292
Background
Definition: hps.h:253
HPS::Type ObjectType() const
Definition: hps.h:28520
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:45866
Definition: hps.h:47871
Definition: hps.h:47244
RegionAlignment
Definition: hps.h:1663
HPS::Type ObjectType() const
Definition: hps.h:13332
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
HPS::Type ObjectType() const
Definition: hps.h:26767
Component
Definition: hps.h:523
Definition: hps.h:449
HPS::Type ObjectType() const
Definition: hps.h:39982
Definition: hps.h:23375
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:45051
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3917
HPS::Type ObjectType() const
Definition: hps.h:12661
Definition: hps.h:2142
Definition: hps.h:28498
Definition: hps.h:39485
Definition: hps.h:20774
HPS::Type ObjectType() const
Definition: hps.h:37673
Definition: hps.h:2172
Event * Clone() const
Definition: hps.h:44949
HPS::Type ObjectType() const
Definition: hps.h:15188
Definition: hps.h:4743
static ModifierKeys KeyLeftAlt()
Definition: hps.h:45676
Default
Definition: hps.h:1936
HPS::Type ObjectType() const
Definition: hps.h:48328
HPS::Type ObjectType() const
Definition: hps.h:29233
Definition: hps.h:47843
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6622
FrameSize
Definition: hps.h:219
Definition: hps.h:22777
Definition: hps.h:4625
HPS::Type ObjectType() const
Definition: hps.h:41611
HPS::Type ObjectType() const
Definition: hps.h:37167
Definition: hps.h:1390
Definition: hps.h:18948
Definition: hps.h:861
Definition: hps.h:5711
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:45799
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:4026
Shape
Definition: hps.h:1066
static ModifierKeys KeyScrollLock()
Definition: hps.h:45652
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:45523
Time update_time
Time taken by the last update.
Definition: hps.h:4896
Definition: hps.h:41578
Definition: hps.h:39077
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:4918
Definition: hps.h:7703
HPS::Type ObjectType() const
Definition: hps.h:24694
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:46261
HPS::Type ObjectType() const
Definition: hps.h:22926
WarningEvent(Event const &in_event)
Definition: hps.h:45002
Definition: hps.h:40631
HPS::Type ObjectType() const
Definition: hps.h:39575
HPS::Type ObjectType() const
Definition: hps.h:12142
Definition: hps.h:1730
static ModifierKeys KeyShift()
Definition: hps.h:45625
Definition: hps.h:153
HPS::Type ObjectType() const
Definition: hps.h:30569
MaterialPreference
Definition: hps.h:1771
Type
Definition: hps.h:437
bool IsValid() const
Definition: hps.h:7141
Definition: hps.h:21937
Definition: hps.h:1519
Cuboid_3D()
Definition: hps.h:3818
ErrorEvent(Event const &in_event)
Definition: hps.h:45073
size_t GetWStrLength() const
Definition: hps.h:7170
Mobility
Definition: hps.h:209
Event * Clone() const
Definition: hps.h:44902
HPS::Type ObjectType() const
Definition: hps.h:11690
Definition: hps.h:8886
Definition: hps.h:27015
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:45955
Definition: hps.h:46903
Definition: hps.h:250
Definition: hps.h:45328
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:4011
void Meta(bool in_state)
Definition: hps.h:45545
Definition: hps.h:6909
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6259
Definition: hps.h:28605
Definition: hps.h:47589
Definition: hps.h:8967
HPS::Type ObjectType() const
Definition: hps.h:15651
HPS_INLINE bool IsValid() const
Definition: hps.h:3868
HPS::Type ObjectType() const
Definition: hps.h:42329
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:45198
Definition: hps.h:22568
Event * Clone() const
Definition: hps.h:45731
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:45768
Definition: hps.h:4567
TimerTickEvent(Event const &in_event)
Definition: hps.h:44827
Definition: hps.h:49180
Definition: hps.h:5858
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6210
HPS::Type ObjectType() const
Definition: hps.h:12934
Definition: hps.h:13063
HPS::Type ObjectType() const
Definition: hps.h:11207
Definition: hps.h:18030
Definition: hps.h:2249
HPS::Type ObjectType() const
Definition: hps.h:42076
Definition: hps.h:26473
InformationEvent()
Definition: hps.h:44918
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5173
Definition: hps.h:41412
Definition: hps.h:12253
Definition: hps.h:45368
Definition: hps.h:14772
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:4903
Definition: hps.h:11666
Infinite line which extends infinitely in both directions along a vector.
Definition: hps.h:49562
bool Shift() const
Definition: hps.h:45462
HPS::Type ObjectType() const
Definition: hps.h:42453
Definition: hps.h:1790
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4097
Definition: hps.h:47549
virtual HPS::Type Type() const
Definition: hps.h:22591
Point_3D< F > max
Definition: hps.h:3812
HPS::Type ObjectType() const
Definition: hps.h:7741
Definition: hps.h:11973
Definition: hps.h:22315
Definition: hps.h:14893
HPS::Type ObjectType() const
Definition: hps.h:49094
HPS::Type ObjectType() const
Definition: hps.h:49202
MouseEvent()
Definition: hps.h:46078
Definition: hps.h:14986
bool LeftShift() const
Definition: hps.h:45494
HPS::Type ObjectType() const
Definition: hps.h:12768
static ModifierKeys KeyLeftControl()
Definition: hps.h:45668
Definition: hps.h:21376
Definition: hps.h:28876
Definition: hps.h:1060
HPS::Type ObjectType() const
Definition: hps.h:17734
Definition: hps.h:12971
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:46761
Definition: hps.h:35027
HPS::Type ObjectType() const
Definition: hps.h:38165
Definition: hps.h:13308
Quality
Definition: hps.h:1050
static const float Infinity
Definition: hps.h:2304
HPS::Type ObjectType() const
Definition: hps.h:26693
Definition: hps.h:5798
ReferenceFrame
Definition: hps.h:1540
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2317
HPS::Type ObjectType() const
Definition: hps.h:14597
HPS::Type ObjectType() const
Definition: hps.h:28826
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6621
HPS::Type ObjectType() const
Definition: hps.h:38355
HPS::Type ObjectType() const
Definition: hps.h:41316
SizeToleranceUnits
Definition: hps.h:1616
Action
Definition: hps.h:46067
The leader line position is supplied in Object Space.
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3990
Definition: hps.h:46415
Definition: hps.h:8927
AppendMode
Definition: hps.h:344
Definition: hps.h:42429
Definition: hps.h:40521
Definition: hps.h:11435
Border
Definition: hps.h:278
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:4908
HPS::Type ObjectType() const
Definition: hps.h:5802
Definition: hps.h:48603
Definition: hps.h:2710
Definition: hps.h:48301
Definition: hps.h:559
virtual HPS::Type Type() const
Definition: hps.h:5801
KeyboardEvent(Event const &in_event)
Definition: hps.h:46233
void RightControl(bool in_state)
Definition: hps.h:45569
Definition: hps.h:22628
Definition: hps.h:38092
bool operator!=(ShapeCoordinate const &in_that) const
Definition: hps.h:6761
UpdateStatus
Definition: hps.h:172
HPS::Type ObjectType() const
Definition: hps.h:9271
Definition: hps.h:2623
Definition: hps.h:32326
Definition: hps.h:40567
HPS::Type ObjectType() const
Definition: hps.h:28235
Definition: hps.h:48645
Definition: hps.h:4385
Definition: hps.h:40826
Definition: hps.h:39955
GreekingMode
Definition: hps.h:1654
FocusLostEvent()
Definition: hps.h:45206
Definition: hps.h:9879
Definition: hps.h:49371
Definition: hps.h:43104
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5185
Definition: hps.h:6106
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:45121
Definition: hps.h:1080
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2325
HPS::Type ObjectType() const
Definition: hps.h:27726
Event * Clone() const
Definition: hps.h:45214
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:46132
Definition: hps.h:46934
Definition: hps.h:46061
Space
Definition: hps.h:2149
ShowKeyboardEvent(Event const &in_event)
Definition: hps.h:45378
ErrorEvent()
Definition: hps.h:45060
Definition: hps.h:45127
Definition: hps.h:6829
HPS::Type ObjectType() const
Definition: hps.h:15010
virtual HPS::Type Type() const
Definition: hps.h:37564
Definition: hps.h:38221
static ModifierKeys KeyRightMeta()
Definition: hps.h:45680
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5703
Definition: hps.h:47034
RelationTest
Definition: hps.h:399
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:45299
Definition: hps.h:45772
virtual HPS::Type Type() const
Definition: hps.h:17827
Definition: hps.h:2264
Definition: hps.h:9682
Definition: hps.h:25289
Definition: hps.h:12743
bool RightMeta() const
Definition: hps.h:45514
Definition: hps.h:23123
HPS::Type ObjectType() const
Definition: hps.h:12477
Definition: hps.h:44636
static ModifierKeys KeyRightControl()
Definition: hps.h:45664
bool LeftControl() const
Definition: hps.h:45502
Definition: hps.h:41621
Definition: hps.h:47968
HPS::Type ObjectType() const
Definition: hps.h:21036
Definition: hps.h:1707
Renderer
Definition: hps.h:1575
TextInputEvent(Event const &in_event)
Definition: hps.h:45236
Definition: hps.h:1478
HPS::Type ObjectType() const
Definition: hps.h:23746
bool None() const
Definition: hps.h:45939
Method
Definition: hps.h:1435
GatheringLevel
Definition: hps.h:1779
Definition: hps.h:330
Definition: hps.h:1410
HPS::Type ObjectType() const
Definition: hps.h:9054
HPS::Type ObjectType() const
Definition: hps.h:40554
Definition: hps.h:47750
ColorSource
Definition: hps.h:1966
Definition: hps.h:45222
HPS::Type ObjectType() const
Definition: hps.h:38069
CappingLevel
Definition: hps.h:1746
Definition: hps.h:18704
HPS::Type ObjectType() const
Definition: hps.h:21752
Definition: hps.h:39300
Definition: hps.h:47048
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:46297
ResolutionUnits
Definition: hps.h:48707
virtual HPS::Type Type() const
Definition: hps.h:14916
Relation
Definition: hps.h:389
Definition: hps.h:1429
HPS::Type ObjectType() const
Definition: hps.h:41159
WorldPoint(Point const &in_point)
Definition: hps.h:5916
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:45891
Definition: hps.h:49342
Definition: hps.h:46976
HPS::Type ObjectType() const
Definition: hps.h:10358
virtual HPS::Type Type() const
Definition: hps.h:23146
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2543
Definition: hps.h:24145
HPS::Type ObjectType() const
Definition: hps.h:6988
Definition: hps.h:37816
Definition: hps.h:19026
void LeftAlt(bool in_state)
Definition: hps.h:45581
TouchEvent(Event const &in_event)
Definition: hps.h:45814
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7273
Definition: hps.h:5156
Definition: hps.h:43377
Definition: hps.h:49366
Definition: hps.h:39814
HPS::Type ObjectType() const
Definition: hps.h:39852
size_t save_region_count
Number of framebuffer regions saved during the last update.
Definition: hps.h:4919
Definition: hps.h:38322
Definition: hps.h:4324
void LeftControl(bool in_state)
Definition: hps.h:45573
HPS::Type ObjectType() const
Definition: hps.h:24263
Definition: hps.h:7086
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5720
HPS::Type ObjectType() const
Definition: hps.h:42864
HPS::Type ObjectType() const
Definition: hps.h:43589
Definition: hps.h:25563
Definition: hps.h:5959
HPS::Type ObjectType() const
Definition: hps.h:46959
bool Alt() const
Definition: hps.h:45470
Definition: hps.h:45907
virtual HPS::Type Type() const
Definition: hps.h:19830
Definition: hps.h:26342
virtual HPS::Type Type() const
Definition: hps.h:18971
Definition: hps.h:29100
HPS::Type ObjectType() const
Definition: hps.h:13255
virtual HPS::Type Type() const
Definition: hps.h:22800
Definition: hps.h:6703
HPS::Type ObjectType() const
Definition: hps.h:18867
HPS::Type ObjectType() const
Definition: hps.h:38410
Definition: hps.h:43281
Definition: hps.h:8977
virtual HPS::Type Type() const
Definition: hps.h:13479
virtual HPS::Type Type() const
Definition: hps.h:21399
Definition: hps.h:47496
Event * Clone() const
Definition: hps.h:45417
HPS::Type ObjectType() const
Definition: hps.h:15804
Grid composed of quadrilaterals.
FrameOptions
Definition: hps.h:227
Definition: hps.h:5909
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:7063
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:46298
Definition: hps.h:44814
HPS::Type ObjectType() const
Definition: hps.h:19832
virtual HPS::Type Type() const
Definition: hps.h:14103
virtual HPS::Type Type() const
Definition: hps.h:44074
Definition: hps.h:42478
Definition: hps.h:27163
virtual HPS::Type Type() const
Definition: hps.h:41314
Definition: hps.h:46303
Operation
Definition: hps.h:464
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5694
float blue
Definition: hps.h:4390
Definition: hps.h:45202
Definition: sprk_dwg.h:43
HPS::Type ObjectType() const
Definition: hps.h:22651
Driver
Definition: hps.h:161
Multiline strings will be left justified.
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7291
PixelPoint(Point const &in_point)
Definition: hps.h:6262
HPS::Type ObjectType() const
Definition: hps.h:6384
virtual HPS::Type Type() const
Definition: hps.h:15186
Mode
Definition: hps.h:1736
static ModifierKeys KeyRightShift()
Definition: hps.h:45656
Definition: hps.h:18843
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:46158
Definition: hps.h:22481
Default
Definition: hps.h:1976
Definition: hps.h:48556
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:4912
HPS::Type ObjectType() const
Definition: hps.h:23274
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:4910
HPS::Type ObjectType() const
Definition: hps.h:23148
HPS::Type ObjectType() const
Definition: hps.h:38308
Code
Definition: hps.h:106
HPS::Type ObjectType() const
Definition: hps.h:30712
UpdateCompletedEvent(Time in_update_time, Window::UpdateStatus in_update_status)
Definition: hps.h:45295
HPS::Type ObjectType() const
Definition: hps.h:25856
HPS::Type ObjectType() const
Definition: hps.h:43229
HPS::Type ObjectType() const
Definition: hps.h:22504
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:46178
Event * Clone() const
Definition: hps.h:45358
Definition: hps.h:15321
Algorithm
Definition: hps.h:1329
bool RightControl() const
Definition: hps.h:45498
Object space units ignoring any scaling components in modelling matrices.
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5179
bool LeftAlt() const
Definition: hps.h:45510
Definition: hps.h:38946
virtual HPS::Type Type() const
Definition: hps.h:10356
Definition: hps.h:45288
HPS::Type ObjectType() const
Definition: hps.h:37566
HPS::Type ObjectType() const
Definition: hps.h:44767
Definition: hps.h:39661
Definition: hps.h:48149
HPS::Type ObjectType() const
Definition: hps.h:16844
Definition: hps.h:1951
Definition: hps.h:33701
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:4901
bool LeftMeta() const
Definition: hps.h:45518
Fastest ambient occlusion but lower quality.
intptr_t GetChannel() const
Definition: hps.h:6338
HPS::Type ObjectType() const
Definition: hps.h:9706
Definition: hps.h:1342
Definition: hps.h:14573
ImageFormat
Definition: hps.h:235
bool NumLock() const
Definition: hps.h:45482
Definition: hps.h:47523
HPS::Type ObjectType() const
Definition: hps.h:33723
Definition: hps.h:47723
HPS::Type ObjectType() const
Definition: hps.h:41654
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3935
Definition: hps.h:13230
Definition: hps.h:47283
Definition: hps.h:11183
Definition: hps.h:7335
HPS::Type ObjectType() const
Definition: hps.h:39780
Definition: hps.h:46622
StandAloneWindowEvent()
Definition: hps.h:45142
HPS::Type ObjectType() const
Definition: hps.h:40051
HPS::Type ObjectType() const
Definition: hps.h:37402
ModifierKeys GetModifierKeys() const
Definition: hps.h:45763
Definition: hps.h:45426
Definition: hps.h:43558
TextInputEvent(char const *in_text)
Definition: hps.h:45232
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:44985
HPS::Type ObjectType() const
Definition: hps.h:39697
Projection
Definition: hps.h:1396
bool RightShift() const
Definition: hps.h:45490
HPS::Type ObjectType() const
Definition: hps.h:13088
HPS::Type ObjectType() const
Definition: hps.h:11858
SizeUnits
Definition: hps.h:48700
Definition: hps.h:47710
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:45029
HPS::Type ObjectType() const
Definition: hps.h:46884
virtual HPS::Type Type() const
Definition: hps.h:20797
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:46086
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5666
HPS::Type ObjectType() const
Definition: hps.h:18567
Preference
Definition: hps.h:1584
InsetBehavior
Definition: hps.h:1846
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:44958
bool X2() const
Definition: hps.h:45959
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:45435
Definition: hps.h:37380
Definition: hps.h:49295
bool Left() const
Definition: hps.h:45943
void Control(bool in_state)
Definition: hps.h:45537
Definition: hps.h:23242
Definition: hps.h:48896
Algorithm
Definition: hps.h:1444
Definition: hps.h:2970
Interpolation
Definition: hps.h:993
Definition: hps.h:18116
Definition: hps.h:45716
HPS::Type ObjectType() const
Definition: hps.h:48584
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:19297
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4082
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:45050
Preference
Definition: hps.h:1466
The base class of all HPS exceptions.
Definition: hps.h:5658
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:45808
Event * Clone() const
Definition: hps.h:46123
Definition: hps.h:6305
HPS::Type ObjectType() const
Definition: hps.h:22802
Definition: hps.h:41085
InformationEvent(Event const &in_event)
Definition: hps.h:44931
Definition: hps.h:13582
void Invalidate()
Definition: hps.h:3880
bool Equals(ShapePoint const &in_that) const
Definition: hps.h:6810
Definition: hps.h:24662
Definition: hps.h:42839
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4886
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5717
Definition: hps.h:39606
Definition: hps.h:46682
The geometry inside the clip region is drawn. Everything outside of it is clipped.
virtual HPS::Type Type() const
Definition: hps.h:12932
HPS::Type ObjectType() const
Definition: hps.h:36890
Justification
Definition: hps.h:1882
size_t restore_region_count
Number of framebuffer regions restored during the last update.
Definition: hps.h:4920
Definition: hps.h:47790
GreekingUnits
Definition: hps.h:1642
Definition: hps.h:6255
HPS::Type ObjectType() const
Definition: hps.h:43970
virtual HPS::Type Type() const
Definition: hps.h:43736
Value
Definition: hps.h:1416
SizeUnits
Definition: hps.h:1484
HPS::Type ObjectType() const
Definition: hps.h:39932
HPS::ByteArray non_db_user_data
Definition: hps.h:46986
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6331
Definition: hps.h:412
The vertex colors applied to faces.
ClipOperation
Definition: hps.h:1302
HPS::Type ObjectType() const
Definition: hps.h:39433
char const * GetBytes() const
Definition: hps.h:7177
MarginUnits
Definition: hps.h:1629
virtual intptr_t Freshen() const
Definition: hps.h:46170
Definition: hps.h:37261
virtual bool Equals(TextInputEvent const &in_that) const
Definition: hps.h:45252
Event * Clone() const
Definition: hps.h:45277
HPS::Type ObjectType() const
Definition: hps.h:38449
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:45725
float green
Definition: hps.h:4389
HPS::Type ObjectType() const
Definition: hps.h:39639
Algorithm
Definition: hps.h:1357
HPS::Type ObjectType() const
Definition: hps.h:10807
Definition: hps.h:39746
HPS::Type ObjectType() const
Definition: hps.h:28898
HPS::Type ObjectType() const
Definition: hps.h:26374
HandleResult
Definition: hps.h:44798
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:4902
HPS::Type ObjectType() const
Definition: hps.h:26130
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:11006
HPS::Type ObjectType() const
Definition: hps.h:41706
HPS::Type ObjectType() const
Definition: hps.h:26495
Status
Definition: hps.h:6311
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6163
HPS::Type ObjectType() const
Definition: hps.h:48923
ImportStatusEvent(Event const &in_event)
Definition: hps.h:45343
Component
Definition: hps.h:418
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6013
bool RightAlt() const
Definition: hps.h:45506
Definition: sprk_parasolid.h:39
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6601
Type
Definition: hps.h:336
Definition: hps.h:47077
static const float NegativeInfinity
Definition: hps.h:2306
Definition: hps.h:47168
HighlightEvent(Event const &in_event)
Definition: hps.h:44885
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7282
HPS::Type ObjectType() const
Definition: hps.h:13606
Justification
Definition: hps.h:1548
HPS::Type ObjectType() const
Definition: hps.h:22148
Definition: hps.h:22903
TextInputEvent()
Definition: hps.h:45226
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:46180
HPS::Type ObjectType() const
Definition: hps.h:11030
InnerWindowPoint(Point const &in_point)
Definition: hps.h:6114
HPS::Type ObjectType() const
Definition: hps.h:30922
HPS::Type ObjectType() const
Definition: hps.h:46704
HPS::Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:44980
InnerConeUnits
Definition: hps.h:496
Definition: hps.h:44740
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3847
Definition: hps.h:13125
virtual HPS::Type Type() const
Definition: hps.h:12475
HPS::Type ObjectType() const
Definition: hps.h:38258
void Alt(bool in_state)
Definition: hps.h:45541
Definition: hps.h:2057
Buttons
Definition: hps.h:46047
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:46205
HPS::Type ObjectType() const
Definition: hps.h:40870
HideKeyboardEvent(Event const &in_event)
Definition: hps.h:45407
bool operator!=(Touch const &in_that) const
Definition: hps.h:6615
Definition: hps.h:44348
Definition: hps.h:25751
Definition: hps.h:100
HPS::Type ObjectType() const
Definition: hps.h:48036
HPS::Type ObjectType() const
Definition: hps.h:49504
Granularity
Definition: hps.h:1374
HPS::Type ObjectType() const
Definition: hps.h:49393
HPS::Type ObjectType() const
Definition: hps.h:36621
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5913
Percentage of the requested font height.
HPS::Type ObjectType() const
Definition: hps.h:9903
HPS::Type ObjectType() const
Definition: hps.h:49590
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:7264
ShowKeyboardEvent()
Definition: hps.h:45372
Definition: hps.h:25016
Style Append Mode.
HPS::SegmentKey & segment_key
Definition: hps.h:47028
Definition: hps.h:46990
Definition: hps.h:38143
Definition: hps.h:1265
Channel
Definition: hps.h:884
Event * Clone() const
Definition: hps.h:45833
void Middle(bool in_state)
Definition: hps.h:45982
Definition: hps.h:30900
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:45100
Definition: hps.h:4894
Action
Definition: hps.h:46192
Event * Clone() const
Definition: hps.h:45168
Definition: hps.h:47817
size_t GetLength() const
Definition: hps.h:7162
HPS::Type ObjectType() const
Definition: hps.h:22593
HPS::Type ObjectType() const
Definition: hps.h:28450
Type
Definition: hps.h:1128
Definition: hps.h:431
HPS::Type ObjectType() const
Definition: hps.h:9816
bool None() const
Definition: hps.h:45458
InterpolationAlgorithm
Definition: hps.h:1507
size_t ClickCount
The number of clicks received.
Definition: hps.h:46182
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
virtual intptr_t Freshen() const
Definition: hps.h:6335
void Reset()
Definition: hps.h:7157
HPS::Type ObjectType() const
Definition: hps.h:41440
HPS::Type ObjectType() const
Definition: hps.h:25511
Definition: hps.h:37134
Action
Definition: hps.h:45133
Code
Definition: hps.h:138
HPS::Type ObjectType() const
Definition: hps.h:44076
Definition: hps.h:43206
Definition: hps.h:47984
static ModifierKeys KeyNumLock()
Definition: hps.h:45648
Event * Clone() const
Definition: hps.h:45091
MouseEvent(Event const &in_event)
Definition: hps.h:46101
bool Right() const
Definition: hps.h:45947
Definition: hps.h:2077
Handedness
Definition: hps.h:1271
virtual bool Empty() const
Definition: hps.h:5760
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:4004
virtual HPS::Type Type() const
Definition: hps.h:5832
static MouseButtons ButtonLeft()
Definition: hps.h:46025
Type
Definition: hps.h:455
virtual HPS::Type Type() const
Definition: hps.h:19295
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:4898
static MouseButtons ButtonMiddle()
Definition: hps.h:46033
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:45791
virtual HPS::Type Type() const
Definition: hps.h:17732
Capping
Definition: hps.h:531
static intptr_t ClassID()
Definition: hps.h:5782
HighlightEvent()
Definition: hps.h:44869
virtual HPS::Type Type() const
Definition: hps.h:15649
virtual HPS::Type ObjectType() const
Definition: hps.h:5756
Definition: hps.h:47103
Definition: hps.h:20084
HPS::Type ObjectType() const
Definition: hps.h:14796
Definition: hps.h:30552
Definition: hps.h:17805
void RightAlt(bool in_state)
Definition: hps.h:45577
Definition: hps.h:6008
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:45890
UpdateType
Definition: hps.h:184
Definition: hps.h:9025
Type
Definition: hps.h:582
virtual intptr_t Freshen() const
Definition: hps.h:44852
Component
Definition: hps.h:363
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3924
Format
Definition: hps.h:40831
Definition: hps.h:48716
CuttingLevel
Definition: hps.h:1763
static ModifierKeys KeyControl()
Definition: hps.h:45630
SizeUnits
Definition: hps.h:1604
Level
Definition: hps.h:1348
HPS::Type ObjectType() const
Definition: hps.h:19523
Definition: hps.h:5676
HPS::Type ObjectType() const
Definition: hps.h:38709
Definition: hps.h:7632
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6061
Definition: hps.h:47643
HPS::Type ObjectType() const
Definition: hps.h:43738
Default
Definition: hps.h:1913
StandAloneWindowEvent(Action in_action)
Definition: hps.h:45147
Definition: hps.h:36260
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:4915
Definition: hps.h:11833
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:44979
Event * Clone() const
Definition: hps.h:45317
The vertex colors applied to faces.
Definition: hps.h:36996
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:4905
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4141
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3959
Definition: hps.h:36858
virtual HPS::Type Type() const
Definition: hps.h:18052
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:4909
Definition: hps.h:357
bool operator==(ShapeCoordinate const &in_that) const
Definition: hps.h:6756
Definition: hps.h:15779
Definition: hps.h:22982
virtual HPS::Type Type() const
Definition: hps.h:13253
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3912
Definition: hps.h:899
Event * Clone() const
Definition: hps.h:45388
HPS::Type ObjectType() const
Definition: hps.h:12995
Time static_time
Time taken to create the static model(s) during the last update.
Definition: hps.h:4897
Definition: hps.h:38891
HPS::Type ObjectType() const
Definition: hps.h:35060
HPS::Type ObjectType() const
Definition: hps.h:18973
Definition: hps.h:46927
virtual HPS::Type Type() const
Definition: hps.h:13086
HPS::Type ObjectType() const
Definition: hps.h:41538
AreaUnits
Definition: hps.h:1457
Definition: hps.h:38560
HPS::Type ObjectType() const
Definition: hps.h:48171
HandednessOptimization
Definition: hps.h:380
Definition: hps.h:6057
HPS::Type ObjectType() const
Definition: hps.h:46538
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3898
HPS::Type ObjectType() const
Definition: hps.h:40653
static ModifierKeys KeyRightAlt()
Definition: hps.h:45672
Definition: hps.h:38830
HPS::Type ObjectType() const
Definition: hps.h:13149
HPS::Type ObjectType() const
Definition: hps.h:19050
Definition: hps.h:25834
Definition: hps.h:9239
Event * Clone() const
Definition: hps.h:46252
Definition: hps.h:10783
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3970
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4126
WindowPoint(Point const &in_point)
Definition: hps.h:6213
HPS::Type ObjectType() const
Definition: hps.h:40983
Definition: hps.h:12117
Alignment
Definition: hps.h:1525
Definition: hps.h:8960
HPS::Key & key
Definition: hps.h:47014
Definition: hps.h:44914
A grid of lines will be drawn in place of characters below the greeking limit.
virtual HPS::Type Type() const
Definition: hps.h:37968
Definition: hps.h:23598
Definition: hps.h:38276
Definition: hps.h:29211
Definition: hps.h:23883
HPS::Type ObjectType() const
Definition: hps.h:42500
Definition: hps.h:27704
Type
Definition: hps.h:867
bool operator==(ShapePoint const &in_that) const
Definition: hps.h:6815
Definition: hps.h:918
ModifierKeys()
Definition: hps.h:45430
Definition: hps.h:26745
static ModifierKeys KeyLeftShift()
Definition: hps.h:45660
Definition: hps.h:1827
Definition: hps.h:24241
Definition: hps.h:29924
Definition: hps.h:47004
Tiling
Definition: hps.h:974
HPS::Type ObjectType() const
Definition: hps.h:27047
Definition: hps.h:45056
HPS::Type ObjectType() const
Definition: hps.h:38522
TouchEvent()
Definition: hps.h:45785
Definition: hps.h:42147
HPS::Type ObjectType() const
Definition: hps.h:21401
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:45740
void LeftShift(bool in_state)
Definition: hps.h:45565
HPS::Type ObjectType() const
Definition: hps.h:22340
Modifiers
Definition: hps.h:45690
Definition: hps.h:517
Definition: hps.h:10333
Definition: hps.h:41290
HPS::Type ObjectType() const
Definition: hps.h:39017
HPS::Type ObjectType() const
Definition: hps.h:6853
HPS::Type ObjectType() const
Definition: hps.h:24177
Definition: hps.h:18543
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4111
HPS::Type ObjectType() const
Definition: hps.h:48743
Definition: hps.h:39890
HPS::Type ObjectType() const
Definition: hps.h:23967
Definition: hps.h:3256
WarningEvent()
Definition: hps.h:44989
bool operator!=(ShapePoint const &in_that) const
Definition: hps.h:6820
Definition: hps.h:26661
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:44846
HPS::Type ObjectType() const
Definition: hps.h:39522
Touch()
Definition: hps.h:6595
Definition: hps.h:12909
Channel
Definition: hps.h:905
Definition: hps.h:38984
ChannelMapping
Definition: hps.h:1020
HPS::Type ObjectType() const
Definition: hps.h:5831
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:4906
Definition: hps.h:36605
Definition: hps.h:43713
Definition: hps.h:1123
ToleranceUnits
Definition: hps.h:372
Kit & operator=(Kit &&in_that)
Definition: hps.h:5849
float red
Definition: hps.h:4388
Definition: hps.h:12821
virtual HPS::Type Type() const
Definition: hps.h:42862
Definition: hps.h:41505
Definition: hps.h:16819
void NumLock(bool in_state)
Definition: hps.h:45553
Control & operator=(Control &&in_that)
Definition: hps.h:5819
Definition: hps.h:47402
HPS::Type ObjectType() const
Definition: hps.h:14918
Definition: hps.h:30821
Cap
Definition: hps.h:1865
void Right(bool in_state)
Definition: hps.h:45978
virtual void Reset()
Definition: hps.h:44790
Definition: hps.h:12452
Definition: hps.h:47940
HPS::Type ObjectType() const
Definition: hps.h:11996
bool Meta() const
Definition: hps.h:45474
Definition: hps.h:46856
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4153
Type
Definition: hps.h:2083
Definition: hps.h:38488
TimerTickEvent()
Definition: hps.h:44818
Definition: hps.h:42307
Definition: hps.h:40848
HPS::Type ObjectType() const
Definition: hps.h:23630
EmergencyHandler()
Definition: hps.h:44329
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5963
Both cylinder ends will be capped.
TouchID ID
TouchID for this Touch.
Definition: hps.h:6620
static ModifierKeys KeyCapsLock()
Definition: hps.h:45644
Definition: hps.h:40018
HPS::Type ObjectType() const
Definition: hps.h:11460
Space
Definition: hps.h:565
HPS::Type ObjectType() const
Definition: hps.h:36282
HPS::Type ObjectType() const
Definition: hps.h:8755
Definition: hps.h:48695
virtual HPS::Type Type() const
Definition: hps.h:14709
Definition: hps.h:6361
Join
Definition: hps.h:1856
Definition: hps.h:26108
Definition: hps.h:7036
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:4914
HPS::Type ObjectType() const
Definition: hps.h:42180
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:4907
Radial bloom.
Control(Control &&in_that)
Definition: hps.h:5814
bool Control() const
Definition: hps.h:45466
Definition: hps.h:5583
HPS::Type ObjectType() const
Definition: hps.h:37838
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:9002
bool CapsLock() const
Definition: hps.h:45478
Type
Definition: hps.h:2044
Definition: hps.h:30690
Definition: hps.h:6155
Definition: hps.h:40961
Rotation
Definition: hps.h:1594
Definition: hps.h:49072
Channel
Definition: hps.h:924
size_t GetHash() const
Driver
Definition: hps.h:48879
Definition: hps.h:23724
HPS::Type ObjectType() const
Definition: hps.h:37970
Action
Definition: hps.h:45777
HPS::Type ObjectType() const
Definition: hps.h:6935
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:46181
Definition: hps.h:41131
Definition: hps.h:48014
Definition: hps.h:28794
Definition: hps.h:2094
virtual HPS::Type Type() const
Definition: hps.h:15802
Definition: hps.h:7344
HPS::Type ObjectType() const
Definition: hps.h:46644
virtual HPS::Type Type() const
Definition: hps.h:11458
Mode
Definition: hps.h:1797
virtual HPS::Type Type() const
Definition: hps.h:21960